Returns the index of the first occurrence of an declaration of type T in the list, or -1 if the list does not contain any declarations of that type. non-null subtype of Any.

indexOfLastInstance

inline fun <T : Any> List<*>.indexOfLastInstance(): Int

Returns the index of the last occurrence of an declaration of type T in the list, or -1 if the list does not contain any declarations of that type.

interfaceAndObjectDeclarations

fun <T : KoDeclarationCastProvider> List<T>.interfaceAndObjectDeclarations(predicate: (KoInterfaceAndObjectDeclaration) -> Boolean? = null): List<KoInterfaceAndObjectDeclaration>

List containing interface and object declarations associated with declarations.

interfaceDeclarations

fun <T : KoDeclarationCastProvider> List<T>.interfaceDeclarations(predicate: (KoInterfaceDeclaration) -> Boolean? = null): List<KoInterfaceDeclaration>

List containing interface declarations associated with declarations.

interfaces

fun <T : KoInterfaceProvider> List<T>.interfaces(includeNested: Boolean = true): List<KoInterfaceDeclaration>

List containing interface declarations.

interfacesAndObjects

fun <T : KoInterfaceAndObjectProvider> List<T>.interfacesAndObjects(includeNested: Boolean = true): List<KoInterfaceAndObjectDeclaration>

List containing interface or/and object declarations.

isSortedByName

fun List<KoNameProvider>.isSortedByName(ascending: Boolean = true, ignoreCase: Boolean = true): Boolean

Extension function to check if a collection of KoNameProvider is sorted by name.

kotlinBasicTypeDeclarations

fun <T : KoDeclarationCastProvider> List<T>.kotlinBasicTypeDeclarations(predicate: (KoKotlinTypeDeclaration) -> Boolean? = null): List<KoKotlinTypeDeclaration>

List containing Kotlin basic type declarations associated with declarations.

kotlinCollectionTypeDeclarations

fun <T : KoDeclarationCastProvider> List<T>.kotlinCollectionTypeDeclarations(predicate: (KoKotlinTypeDeclaration) -> Boolean? = null): List<KoKotlinTypeDeclaration>

List containing Kotlin collection type declarations associated with declarations.

kotlinTypeDeclarations

fun <T : KoDeclarationCastProvider> List<T>.kotlinTypeDeclarations(predicate: (KoKotlinTypeDeclaration) -> Boolean? = null): List<KoKotlinTypeDeclaration>

List containing Kotlin type declarations associated with declarations.

objectDeclarations

fun <T : KoDeclarationCastProvider> List<T>.objectDeclarations(predicate: (KoObjectDeclaration) -> Boolean? = null): List<KoObjectDeclaration>

List containing object declarations associated with declarations.

objects

fun <T : KoObjectProvider> List<T>.objects(includeNested: Boolean = true): List<KoObjectDeclaration>

List containing object declarations.

parentClasses

fun <T : KoParentClassProvider> List<T>.parentClasses(indirectParents: Boolean = false): List<KoParentDeclaration>

List containing parent classes.

parentInterfaces

fun <T : KoParentInterfaceProvider> List<T>.parentInterfaces(indirectParents: Boolean = false): List<KoParentDeclaration>

List containing parent interfaces.

parents

fun <T : KoParentProvider> List<T>.parents(indirectParents: Boolean = false): List<KoParentDeclaration>

List containing parent declarations.

fun <T : KoBaseProvider> List<T>.print(prefix: String? = null, predicate: (T) -> String? = null): List<T>

Print the declarations.

properties

fun <T : KoPropertyProvider> List<T>.properties(includeNested: Boolean = true): List<KoPropertyDeclaration>

List containing property declarations.

sourceDeclarations

fun <T : KoSourceDeclarationProvider> List<T>.sourceDeclarations(predicate: (KoDeclarationCastProvider) -> Boolean? = null): List<KoDeclarationCastProvider>

List containing source declarations associated with types.

testClasses

fun <T : KoTestClassProvider> List<T>.testClasses(testPropertyName: String = "sut", moduleName: String? = null, sourceSetName: String? = null): List<KoBaseDeclaration>

List containing test classes.

fun <T : KoTestClassProvider> List<T>.testClasses(moduleName: String? = null, sourceSetName: String? = null, predicate: (KoClassDeclaration) -> Boolean): List<KoBaseDeclaration>

List containing test classes matching the predicate.

typeAliasDeclarations

fun <T : KoDeclarationCastProvider> List<T>.typeAliasDeclarations(predicate: (KoTypeAliasDeclaration) -> Boolean? = null): List<KoTypeAliasDeclaration>

List containing type alias declarations associated with declarations.

typeParameterDeclarations

fun <T : KoDeclarationCastProvider> List<T>.typeParameterDeclarations(predicate: (KoTypeParameterDeclaration) -> Boolean? = null): List<KoTypeParameterDeclaration>

List containing type parameter declarations associated with declarations.

withAbsolutePath

fun <T : KoPathProvider> List<T>.withAbsolutePath(paths: Collection<String>): List<T>

fun <T : KoPathProvider> List<T>.withAbsolutePath(paths: List<String>): List<T>

fun <T : KoPathProvider> List<T>.withAbsolutePath(path: String, vararg paths: String): List<T>

List containing declarations with absolute path.

withAlias

fun <T : KoAliasProvider> List<T>.withAlias(predicate: (KoImportAliasDeclaration) -> Boolean? = null): List<T>

List containing declarations with the specified import alias.

withAllAnnotations

fun <T : KoAnnotationProvider> List<T>.withAllAnnotations(predicate: (KoAnnotationDeclaration) -> Boolean): List<T>

List containing declarations that have all annotations satisfying the provided predicate.

withAllAnnotationsNamed

fun <T : KoAnnotationProvider> List<T>.withAllAnnotationsNamed(names: Collection<String>): List<T>

fun <T : KoAnnotationProvider> List<T>.withAllAnnotationsNamed(name: String, vararg names: String): List<T>

List containing declarations that have all specified annotations.

withAllAnnotationsOf

fun <T : KoAnnotationProvider> List<T>.withAllAnnotationsOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoAnnotationProvider> List<T>.withAllAnnotationsOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations that have all annotations of the specified KClass type.

withAllArguments

fun <T : KoArgumentProvider> List<T>.withAllArguments(predicate: (KoArgumentDeclaration) -> Boolean): List<T>

List containing declarations that have all arguments satisfying the provided predicate.

withAllArgumentsNamed

fun <T : KoArgumentProvider> List<T>.withAllArgumentsNamed(names: Collection<String>): List<T>

fun <T : KoArgumentProvider> List<T>.withAllArgumentsNamed(name: String, vararg names: String): List<T>

List containing declarations that have all specified arguments.

withAllChildren

fun <T : KoChildProvider> List<T>.withAllChildren(indirectChildren: Boolean = false, predicate: (KoChildDeclaration) -> Boolean): List<T>

List containing declarations that have all children satisfying the provided predicate.

withAllChildrenNamed

fun <T : KoChildProvider> List<T>.withAllChildrenNamed(names: Collection<String>, indirectChildren: Boolean = false): List<T>

fun <T : KoChildProvider> List<T>.withAllChildrenNamed(name: String, vararg names: String, indirectChildren: Boolean = false): List<T>

List containing declarations that have all specified children.

withAllChildrenOf

fun <T : KoChildProvider> List<T>.withAllChildrenOf(kClasses: Collection<KClass<*>>, indirectChildren: Boolean = false): List<T>

fun <T : KoChildProvider> List<T>.withAllChildrenOf(kClass: KClass<*>, vararg kClasses: KClass<*>, indirectChildren: Boolean = false): List<T>

List containing declarations that have all children of the specified KClass type.

withAllClasses

fun <T : KoClassProvider> List<T>.withAllClasses(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoClassDeclaration) -> Boolean): List<T>

List containing declarations that have all classes satisfying the provided predicate.

withAllClassesAndInterfaces

fun <T : KoClassAndInterfaceProvider> List<T>.withAllClassesAndInterfaces(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoClassAndInterfaceDeclaration) -> Boolean): List<T>

List containing declarations that have all classes and interfaces satisfying the provided predicate.

withAllClassesAndInterfacesAndObjects

fun <T : KoClassAndInterfaceAndObjectProvider> List<T>.withAllClassesAndInterfacesAndObjects(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoClassAndInterfaceAndObjectDeclaration) -> Boolean): List<T>

List containing declarations that have all classes, interfaces and objects satisfying the provided predicate.

withAllClassesAndInterfacesAndObjectsNamed

fun <T : KoClassAndInterfaceAndObjectProvider> List<T>.withAllClassesAndInterfacesAndObjectsNamed(names: Collection<String>, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

fun <T : KoClassAndInterfaceAndObjectProvider> List<T>.withAllClassesAndInterfacesAndObjectsNamed(name: String, vararg names: String, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations that have all specified classes, interfaces and objects.

withAllClassesAndInterfacesNamed

fun <T : KoClassAndInterfaceProvider> List<T>.withAllClassesAndInterfacesNamed(names: Collection<String>, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

fun <T : KoClassAndInterfaceProvider> List<T>.withAllClassesAndInterfacesNamed(name: String, vararg names: String, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations that have all specified classes and interfaces.

withAllClassesAndObjects

fun <T : KoClassAndObjectProvider> List<T>.withAllClassesAndObjects(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoClassAndObjectDeclaration) -> Boolean): List<T>

List containing declarations that have all classes and objects satisfying the provided predicate.

withAllClassesAndObjectsNamed

fun <T : KoClassAndObjectProvider> List<T>.withAllClassesAndObjectsNamed(names: Collection<String>, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

fun <T : KoClassAndObjectProvider> List<T>.withAllClassesAndObjectsNamed(name: String, vararg names: String, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations that have all specified classes and objects.

withAllClassesNamed

fun <T : KoClassProvider> List<T>.withAllClassesNamed(names: Collection<String>, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

fun <T : KoClassProvider> List<T>.withAllClassesNamed(name: String, vararg names: String, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations that have all specified classes.

withAllConstructors

fun <T : KoConstructorProvider> List<T>.withAllConstructors(predicate: (KoConstructorDeclaration) -> Boolean): List<T>

List containing declarations whose all constructors match the given predicate.

withAllDeclarations

fun <T : KoDeclarationProvider> List<T>.withAllDeclarations(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoBaseDeclaration) -> Boolean): List<T>

List containing declarations that have all declarations satisfying the provided predicate.

withAllEnumConstants

fun <T : KoEnumConstantProvider> List<T>.withAllEnumConstants(predicate: (KoEnumConstantDeclaration) -> Boolean): List<T>

List containing declarations that have all enum constants satisfying the provided predicate.

withAllEnumConstantsNamed

fun <T : KoEnumConstantProvider> List<T>.withAllEnumConstantsNamed(names: Collection<String>): List<T>

fun <T : KoEnumConstantProvider> List<T>.withAllEnumConstantsNamed(name: String, vararg names: String): List<T>

List containing declarations that have all specified enum constants.

withAllExternalParents

fun <T : KoExternalParentProvider> List<T>.withAllExternalParents(indirectParents: Boolean = false, predicate: (KoParentDeclaration) -> Boolean): List<T>

List containing declarations that have all external parents satisfying the provided predicate. The external parent is a parent defined outside the project codebase (defined inside external library).

withAllExternalParentsNamed

fun <T : KoExternalParentProvider> List<T>.withAllExternalParentsNamed(names: Collection<String>, indirectParents: Boolean = false): List<T>

fun <T : KoExternalParentProvider> List<T>.withAllExternalParentsNamed(name: String, vararg names: String, indirectParents: Boolean = false): List<T>

List containing declarations that have all specified external parents. The external parent is a parent defined outside the project codebase (defined inside external library).

withAllExternalParentsOf

fun <T : KoExternalParentProvider> List<T>.withAllExternalParentsOf(kClasses: Collection<KClass<*>>, indirectParents: Boolean = false): List<T>

fun <T : KoExternalParentProvider> List<T>.withAllExternalParentsOf(kClass: KClass<*>, vararg kClasses: KClass<*>, indirectParents: Boolean = false): List<T>

List containing declarations that have all external parents of the specified KClass type. The external parent is a parent defined outside the project codebase (defined inside external library).

withAllFunctions

fun <T : KoFunctionProvider> List<T>.withAllFunctions(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoFunctionDeclaration) -> Boolean): List<T>

List containing declarations that have all functions satisfying the provided predicate.

withAllFunctionsNamed

fun <T : KoFunctionProvider> List<T>.withAllFunctionsNamed(names: Collection<String>, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

fun <T : KoFunctionProvider> List<T>.withAllFunctionsNamed(name: String, vararg names: String, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations that have all specified functions.

withAllImportAliases

fun <T : KoImportAliasProvider> List<T>.withAllImportAliases(predicate: (KoImportAliasDeclaration) -> Boolean): List<T>

List containing declarations that have all import aliases satisfying the provided predicate.

withAllImportAliasesNamed

fun <T : KoImportAliasProvider> List<T>.withAllImportAliasesNamed(names: Collection<String>): List<T>

fun <T : KoImportAliasProvider> List<T>.withAllImportAliasesNamed(name: String, vararg names: String): List<T>

List containing declarations that have all specified import aliases.

withAllImports

fun <T : KoImportProvider> List<T>.withAllImports(predicate: (KoImportDeclaration) -> Boolean): List<T>

List containing declarations that have all imports satisfying the provided predicate.

withAllImportsNamed

fun <T : KoImportProvider> List<T>.withAllImportsNamed(names: Collection<String>): List<T>

fun <T : KoImportProvider> List<T>.withAllImportsNamed(name: String, vararg names: String): List<T>

List containing declarations that have all specified imports.

withAllInitBlocks

fun <T : KoInitBlockProvider> List<T>.withAllInitBlocks(predicate: (KoInitBlockDeclaration) -> Boolean): List<T>

List containing declarations that have all init blocks satisfying the provided predicate.

withAllInterfaces

fun <T : KoInterfaceProvider> List<T>.withAllInterfaces(includeNested: Boolean = true, predicate: (KoInterfaceDeclaration) -> Boolean): List<T>

List containing declarations that have all interfaces satisfying the provided predicate.

withAllInterfacesAndObjects

fun <T : KoInterfaceAndObjectProvider> List<T>.withAllInterfacesAndObjects(includeNested: Boolean = true, predicate: (KoInterfaceAndObjectDeclaration) -> Boolean): List<T>

List containing declarations that have all interfaces and objects satisfying the provided predicate.

withAllInterfacesAndObjectsNamed

fun <T : KoInterfaceAndObjectProvider> List<T>.withAllInterfacesAndObjectsNamed(names: Collection<String>, includeNested: Boolean = true): List<T>

fun <T : KoInterfaceAndObjectProvider> List<T>.withAllInterfacesAndObjectsNamed(name: String, vararg names: String, includeNested: Boolean = true): List<T>

List containing declarations that have all specified interfaces and objects.

withAllInterfacesNamed

fun <T : KoInterfaceProvider> List<T>.withAllInterfacesNamed(names: Collection<String>, includeNested: Boolean = true): List<T>

fun <T : KoInterfaceProvider> List<T>.withAllInterfacesNamed(name: String, vararg names: String, includeNested: Boolean = true): List<T>

List containing declarations that have all specified interfaces.

withAllLocalClasses

fun <T : KoLocalClassProvider> List<T>.withAllLocalClasses(predicate: (KoClassDeclaration) -> Boolean): List<T>

List containing declarations that have all local classes satisfying the provided predicate.

withAllLocalClassesNamed

fun <T : KoLocalClassProvider> List<T>.withAllLocalClassesNamed(names: Collection<String>): List<T>

fun <T : KoLocalClassProvider> List<T>.withAllLocalClassesNamed(name: String, vararg names: String): List<T>

List containing declarations that have all specified local classes.

withAllLocalDeclarations

fun <T : KoLocalDeclarationProvider> List<T>.withAllLocalDeclarations(predicate: (KoBaseDeclaration) -> Boolean): List<T>

List containing declarations that have all local declarations satisfying the provided predicate.

withAllLocalFunctions

fun <T : KoLocalFunctionProvider> List<T>.withAllLocalFunctions(predicate: (KoFunctionDeclaration) -> Boolean): List<T>

List containing declarations that have all local functions satisfying the provided predicate.

withAllLocalFunctionsNamed

fun <T : KoLocalFunctionProvider> List<T>.withAllLocalFunctionsNamed(names: Collection<String>): List<T>

fun <T : KoLocalFunctionProvider> List<T>.withAllLocalFunctionsNamed(name: String, vararg names: String): List<T>

List containing declarations that have all specified local functions.

withAllObjects

fun <T : KoObjectProvider> List<T>.withAllObjects(includeNested: Boolean = true, predicate: (KoObjectDeclaration) -> Boolean): List<T>

List containing declarations that have all objects satisfying the provided predicate.

withAllObjectsNamed

fun <T : KoObjectProvider> List<T>.withAllObjectsNamed(names: Collection<String>, includeNested: Boolean = true): List<T>

fun <T : KoObjectProvider> List<T>.withAllObjectsNamed(name: String, vararg names: String, includeNested: Boolean = true): List<T>

List containing declarations that have all specified objects.

withAllParameters

fun <T : KoFunctionTypeDeclarationProvider> List<T>.withAllParameters(predicate: (KoParameterDeclaration) -> Boolean): List<T>

Filters the list by requiring that all parameters match the given predicate.

fun <T : KoParametersProvider> List<T>.withAllParameters(predicate: (KoParameterDeclaration) -> Boolean): List<T>

List containing declarations that have all parameters satisfying the provided predicate.

withAllParametersNamed

fun <T : KoParametersProvider> List<T>.withAllParametersNamed(names: Collection<String>): List<T>

fun <T : KoParametersProvider> List<T>.withAllParametersNamed(name: String, vararg names: String): List<T>

List containing declarations that have all specified parameters.

withAllParameterTypes

fun <T : KoFunctionTypeDeclarationProvider> List<T>.~~withAllParameterTypes~~(predicate: (KoParameterDeclaration) -> Boolean): List<T>

Filters the list by requiring that all parameter types match the given predicate.

withAllParentClasses

fun <T : KoParentClassProvider> List<T>.withAllParentClasses(indirectParents: Boolean = false, predicate: (KoParentDeclaration) -> Boolean): List<T>

List containing declarations that have all parent classes satisfying the provided predicate.

withAllParentClassesNamed

fun <T : KoParentClassProvider> List<T>.withAllParentClassesNamed(names: Collection<String>, indirectParents: Boolean = false): List<T>

fun <T : KoParentClassProvider> List<T>.withAllParentClassesNamed(name: String, vararg names: String, indirectParents: Boolean = false): List<T>

List containing declarations that have all specified parent classes.

withAllParentClassesOf

fun <T : KoParentClassProvider> List<T>.withAllParentClassesOf(kClasses: Collection<KClass<*>>, indirectParents: Boolean = false): List<T>

fun <T : KoParentClassProvider> List<T>.withAllParentClassesOf(kClass: KClass<*>, vararg kClasses: KClass<*>, indirectParents: Boolean = false): List<T>

List containing declarations that have all parent classes of the specified KClass type.

withAllParentInterfaces

fun <T : KoParentInterfaceProvider> List<T>.withAllParentInterfaces(indirectParents: Boolean = false, predicate: (KoParentDeclaration) -> Boolean): List<T>

List containing declarations that have all parent interfaces satisfying the provided predicate.

withAllParentInterfacesNamed

fun <T : KoParentInterfaceProvider> List<T>.withAllParentInterfacesNamed(names: Collection<String>, indirectParents: Boolean = false): List<T>

fun <T : KoParentInterfaceProvider> List<T>.withAllParentInterfacesNamed(name: String, vararg names: String, indirectParents: Boolean = false): List<T>

List containing declarations that have all specified parent interfaces.

withAllParentInterfacesOf

fun <T : KoParentInterfaceProvider> List<T>.withAllParentInterfacesOf(kClasses: Collection<KClass<*>>, indirectParents: Boolean = false): List<T>

fun <T : KoParentInterfaceProvider> List<T>.withAllParentInterfacesOf(kClass: KClass<*>, vararg kClasses: KClass<*>, indirectParents: Boolean = false): List<T>

List containing declarations that have all parent interfaces of the specified KClass type.

withAllParents

fun <T : KoParentProvider> List<T>.withAllParents(indirectParents: Boolean = false, predicate: (KoParentDeclaration) -> Boolean): List<T>

List containing declarations that have all parents satisfying the provided predicate.

withAllParentsNamed

fun <T : KoParentProvider> List<T>.withAllParentsNamed(names: Collection<String>, indirectParents: Boolean = false): List<T>

fun <T : KoParentProvider> List<T>.withAllParentsNamed(name: String, vararg names: String, indirectParents: Boolean = false): List<T>

List containing declarations that have all specified parents.

withAllParentsOf

fun <T : KoParentProvider> List<T>.withAllParentsOf(kClasses: Collection<KClass<*>>, indirectParents: Boolean = false): List<T>

fun <T : KoParentProvider> List<T>.withAllParentsOf(kClass: KClass<*>, vararg kClasses: KClass<*>, indirectParents: Boolean = false): List<T>

List containing declarations that have all parents of the specified KClass type.

withAllProperties

fun <T : KoPropertyProvider> List<T>.withAllProperties(includeNested: Boolean = true, predicate: (KoPropertyDeclaration) -> Boolean): List<T>

List containing declarations that have all properties satisfying the provided predicate.

withAllPropertiesNamed

fun <T : KoPropertyProvider> List<T>.withAllPropertiesNamed(names: Collection<String>, includeNested: Boolean = true): List<T>

fun <T : KoPropertyProvider> List<T>.withAllPropertiesNamed(name: String, vararg names: String, includeNested: Boolean = true): List<T>

List containing declarations that have all specified properties.

withAllSecondaryConstructors

fun <T : KoSecondaryConstructorsProvider> List<T>.withAllSecondaryConstructors(predicate: (KoSecondaryConstructorDeclaration) -> Boolean): List<T>

List containing declarations that have all secondary constructors satisfying the provided predicate.

withAllTypeAliases

fun <T : KoTypeAliasProvider> List<T>.withAllTypeAliases(predicate: (KoTypeAliasDeclaration) -> Boolean): List<T>

List containing declarations that have all type aliases satisfying the provided predicate.

withAllTypeAliasesNamed

fun <T : KoTypeAliasProvider> List<T>.withAllTypeAliasesNamed(names: Collection<String>): List<T>

fun <T : KoTypeAliasProvider> List<T>.withAllTypeAliasesNamed(name: String, vararg names: String): List<T>

List containing declarations that have all specified type aliases.

withAllTypeArguments

fun <T : KoTypeArgumentProvider> List<T>.withAllTypeArguments(predicate: (KoTypeArgumentDeclaration) -> Boolean): List<T>

List containing declarations that have all type arguments satisfying the provided predicate.

withAllTypeArgumentsNamed

fun <T : KoTypeArgumentProvider> List<T>.withAllTypeArgumentsNamed(names: Collection<String>): List<T>

fun <T : KoTypeArgumentProvider> List<T>.withAllTypeArgumentsNamed(name: String, vararg names: String): List<T>

List containing declarations that have all specified type arguments.

withAllTypeParameters

fun <T : KoTypeParameterProvider> List<T>.withAllTypeParameters(predicate: (KoTypeParameterDeclaration) -> Boolean): List<T>

List containing declarations that have all type parameters satisfying the provided predicate.

withAllTypeParametersNamed

fun <T : KoTypeParameterProvider> List<T>.withAllTypeParametersNamed(names: Collection<String>): List<T>

fun <T : KoTypeParameterProvider> List<T>.withAllTypeParametersNamed(name: String, vararg names: String): List<T>

List containing declarations that have all specified type parameters.

withAllUpperBounds

fun <T : KoUpperBoundsProvider> List<T>.withAllUpperBounds(predicate: (KoTypeDeclaration) -> Boolean): List<T>

List containing declarations that have all upper bounds satisfying the provided predicate.

withAllUpperBoundsNamed

fun <T : KoUpperBoundsProvider> List<T>.withAllUpperBoundsNamed(names: Collection<String>): List<T>

fun <T : KoUpperBoundsProvider> List<T>.withAllUpperBoundsNamed(name: String, vararg names: String): List<T>

List containing declarations that have all specified upper bounds.

withAllVariables

fun <T : KoVariableProvider> List<T>.withAllVariables(predicate: (KoVariableDeclaration) -> Boolean): List<T>

List containing declarations that have all variables satisfying the provided predicate.

withAllVariablesNamed

fun <T : KoVariableProvider> List<T>.withAllVariablesNamed(names: Collection<String>): List<T>

fun <T : KoVariableProvider> List<T>.withAllVariablesNamed(name: String, vararg names: String): List<T>

List containing declarations that have all specified variables.

withAnnotation

fun <T : KoAnnotationProvider> List<T>.withAnnotation(predicate: (KoAnnotationDeclaration) -> Boolean): List<T>

List containing declarations that have at least one annotation satisfying the provided predicate.

withAnnotationNamed

fun <T : KoAnnotationProvider> List<T>.withAnnotationNamed(names: Collection<String>): List<T>

fun <T : KoAnnotationProvider> List<T>.withAnnotationNamed(name: String, vararg names: String): List<T>

List containing declarations that have at least one annotation with the specified name(s).

withAnnotationOf

fun <T : KoAnnotationProvider> List<T>.withAnnotationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoAnnotationProvider> List<T>.withAnnotationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations that have at least one annotation of the specified KClass type.

withAnnotations

fun <T : KoAnnotationProvider> List<T>.withAnnotations(): List<T>

List containing declarations with any annotation.

fun <T : KoAnnotationProvider> List<T>.withAnnotations(predicate: (List<KoAnnotationDeclaration>) -> Boolean): List<T>

List containing declarations with annotation declarations satisfying the predicate.

withArgument

fun <T : KoArgumentProvider> List<T>.withArgument(predicate: (KoArgumentDeclaration) -> Boolean): List<T>

List containing declarations that have at least one argument satisfying the provided predicate.

withArgumentNamed

fun <T : KoArgumentProvider> List<T>.withArgumentNamed(names: Collection<String>): List<T>

fun <T : KoArgumentProvider> List<T>.withArgumentNamed(name: String, vararg names: String): List<T>

List containing declarations that have at least one argument with the specified name(s).

withArguments

fun <T : KoArgumentProvider> List<T>.withArguments(): List<T>

List containing declarations with any argument.

fun <T : KoArgumentProvider> List<T>.withArguments(predicate: (List<KoArgumentDeclaration>) -> Boolean): List<T>

List containing declarations with argument declarations satisfying the predicate.

withBareSourceType

fun <T : KoSourceTypeProvider> List<T>.withBareSourceType(names: Collection<String>): List<T>

fun <T : KoSourceTypeProvider> List<T>.withBareSourceType(name: String, vararg names: String): List<T>

List containing declarations with base source type.

withBareSourceTypeOf

fun <T : KoSourceTypeProvider> List<T>.withBareSourceTypeOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoSourceTypeProvider> List<T>.withBareSourceTypeOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations with bare source type of.

withBlockBody

fun <T : KoBodyProvider> List<T>.withBlockBody(): List<T>

List containing declarations with block body.

withChild

fun <T : KoChildProvider> List<T>.withChild(indirectChildren: Boolean = false, predicate: (KoChildDeclaration) -> Boolean): List<T>

List containing declarations that have at least one child satisfying the provided predicate.

withChildNamed

fun <T : KoChildProvider> List<T>.withChildNamed(names: Collection<String>, indirectChildren: Boolean = false): List<T>

fun <T : KoChildProvider> List<T>.withChildNamed(name: String, vararg names: String, indirectChildren: Boolean = false): List<T>

List containing declarations that have at least one child with the specified name(s).

withChildOf

fun <T : KoChildProvider> List<T>.withChildOf(kClasses: Collection<KClass<*>>, indirectChildren: Boolean = false): List<T>

fun <T : KoChildProvider> List<T>.withChildOf(kClass: KClass<*>, vararg kClasses: KClass<*>, indirectChildren: Boolean = false): List<T>

List containing declarations that have at least one child of the specified KClass type.

withChildren

fun <T : KoChildProvider> List<T>.withChildren(indirectChildren: Boolean = false): List<T>

List containing declarations with class or interface child.

fun <T : KoChildProvider> List<T>.withChildren(indirectChildren: Boolean = false, predicate: (List<KoChildDeclaration>) -> Boolean): List<T>

List containing declarations with child declarations satisfying the predicate.

withClass

fun <T : KoClassProvider> List<T>.withClass(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoClassDeclaration) -> Boolean): List<T>

List containing declarations that have at least one class satisfying the provided predicate.

withClassDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withClassDeclaration(predicate: (KoClassDeclaration) -> Boolean? = null): List<T>

List containing declarations with the specified class declaration.

withClassDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withClassDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withClassDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations with class declaration of.

withClasses

fun <T : KoClassProvider> List<T>.withClasses(includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations with any class.

fun <T : KoClassProvider> List<T>.withClasses(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (List<KoClassDeclaration>) -> Boolean): List<T>

List containing declarations with class declarations satisfying the predicate.

withClassesAndInterfaces

fun <T : KoClassAndInterfaceProvider> List<T>.withClassesAndInterfaces(includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations with any class or interface.

fun <T : KoClassAndInterfaceProvider> List<T>.withClassesAndInterfaces(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (List<KoClassAndInterfaceDeclaration>) -> Boolean): List<T>

List containing declarations with classes and interfaces declarations satisfying the predicate.

withClassesAndInterfacesAndObjects

fun <T : KoClassAndInterfaceAndObjectProvider> List<T>.withClassesAndInterfacesAndObjects(includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations with any class, interface or object.

fun <T : KoClassAndInterfaceAndObjectProvider> List<T>.withClassesAndInterfacesAndObjects(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (List<KoClassAndInterfaceAndObjectDeclaration>) -> Boolean): List<T>

List containing declarations with classes, interfaces and objects declarations satisfying the predicate.

withClassesAndObjects

fun <T : KoClassAndObjectProvider> List<T>.withClassesAndObjects(includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations with any class or object.

fun <T : KoClassAndObjectProvider> List<T>.withClassesAndObjects(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (List<KoClassAndObjectDeclaration>) -> Boolean): List<T>

List containing declarations with classes and objects declarations satisfying the predicate.

withClassNamed

fun <T : KoClassProvider> List<T>.withClassNamed(names: Collection<String>, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

fun <T : KoClassProvider> List<T>.withClassNamed(name: String, vararg names: String, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations that have at least one class with the specified name(s).

withClassOrInterface

fun <T : KoClassAndInterfaceProvider> List<T>.withClassOrInterface(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoClassAndInterfaceDeclaration) -> Boolean): List<T>

List containing declarations that have at least one class or interface satisfying the provided predicate.

withClassOrInterfaceDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withClassOrInterfaceDeclaration(predicate: (KoClassAndInterfaceDeclaration) -> Boolean? = null): List<T>

List containing declarations with the specified class or interface declaration.

withClassOrInterfaceDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withClassOrInterfaceDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withClassOrInterfaceDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations with class or interface declaration of.

withClassOrInterfaceNamed

fun <T : KoClassAndInterfaceProvider> List<T>.withClassOrInterfaceNamed(names: Collection<String>, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

fun <T : KoClassAndInterfaceProvider> List<T>.withClassOrInterfaceNamed(name: String, vararg names: String, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations that have at least one class or interface with the specified name(s).

withClassOrInterfaceOrObject

fun <T : KoClassAndInterfaceAndObjectProvider> List<T>.withClassOrInterfaceOrObject(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoClassAndInterfaceAndObjectDeclaration) -> Boolean): List<T>

List containing declarations that have at least one class, interface or object satisfying the provided predicate.

withClassOrInterfaceOrObjectDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withClassOrInterfaceOrObjectDeclaration(predicate: (KoClassAndInterfaceAndObjectDeclaration) -> Boolean? = null): List<T>

List containing declarations with the specified class, interface or object declaration.

withClassOrInterfaceOrObjectDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withClassOrInterfaceOrObjectDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withClassOrInterfaceOrObjectDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations with class, interface or object declaration of.

withClassOrInterfaceOrObjectNamed

fun <T : KoClassAndInterfaceAndObjectProvider> List<T>.withClassOrInterfaceOrObjectNamed(names: Collection<String>, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

fun <T : KoClassAndInterfaceAndObjectProvider> List<T>.withClassOrInterfaceOrObjectNamed(name: String, vararg names: String, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations that have at least one class, interface or object with the specified name(s).

withClassOrObject

fun <T : KoClassAndObjectProvider> List<T>.withClassOrObject(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoClassAndObjectDeclaration) -> Boolean): List<T>

List containing declarations that have at least one class or object satisfying the provided predicate.

withClassOrObjectDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withClassOrObjectDeclaration(predicate: (KoClassAndObjectDeclaration) -> Boolean? = null): List<T>

List containing declarations with the specified class or object declaration.

withClassOrObjectDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withClassOrObjectDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withClassOrObjectDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations with class or object declaration of.

withClassOrObjectNamed

fun <T : KoClassAndObjectProvider> List<T>.withClassOrObjectNamed(names: Collection<String>, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

fun <T : KoClassAndObjectProvider> List<T>.withClassOrObjectNamed(name: String, vararg names: String, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations that have at least one class or object with the specified name(s).

withConstructor

fun <T : KoConstructorProvider> List<T>.withConstructor(predicate: (KoConstructorDeclaration) -> Boolean): List<T>

List containing declarations whose at least one constructor matches the given predicate.

withConstructorDefined

fun <T : KoIsConstructorDefinedProvider> List<T>.withConstructorDefined(): List<T>

List containing declarations defined within a constructor.

withConstructors

fun <T : KoConstructorProvider> List<T>.withConstructors(): List<T>

List containing declarations with constructor.

fun <T : KoConstructorProvider> List<T>.withConstructors(predicate: (List<KoConstructorDeclaration>) -> Boolean): List<T>

List containing declarations with constructor declarations satisfying the predicate.

withDeclaration

fun <T : KoDeclarationProvider> List<T>.withDeclaration(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoBaseDeclaration) -> Boolean): List<T>

List containing declarations that have at least one declaration satisfying the provided predicate.

withDeclarations

fun <T : KoDeclarationProvider> List<T>.withDeclarations(includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations with any declaration.

fun <T : KoDeclarationProvider> List<T>.withDeclarations(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (List<KoBaseDeclaration>) -> Boolean): List<T>

List containing declarations with declarations satisfying the predicate.

withDefaultValue

fun <T : KoDefaultValueProvider> List<T>.withDefaultValue(vararg values: String): List<T>

fun <T : KoDefaultValueProvider> List<T>.withDefaultValue(values: Collection<String>): List<T>

List containing declarations with default value.

withDelegate

fun <T : KoDelegateProvider> List<T>.withDelegate(vararg names: String): List<T>

fun <T : KoDelegateProvider> List<T>.withDelegate(names: Collection<String>): List<T>

List containing declarations with delegate with given name.

withEnumConstant

fun <T : KoEnumConstantProvider> List<T>.withEnumConstant(predicate: (KoEnumConstantDeclaration) -> Boolean): List<T>

List containing declarations that have at least one enum constant satisfying the provided predicate.

withEnumConstantNamed

fun <T : KoEnumConstantProvider> List<T>.withEnumConstantNamed(names: Collection<String>): List<T>

fun <T : KoEnumConstantProvider> List<T>.withEnumConstantNamed(name: String, vararg names: String): List<T>

List containing declarations that have at least one enum constant with the specified name(s).

withEnumConstants

fun <T : KoEnumConstantProvider> List<T>.withEnumConstants(): List<T>

List containing declarations with any enum constant.

fun <T : KoEnumConstantProvider> List<T>.withEnumConstants(predicate: (List<KoEnumConstantDeclaration>) -> Boolean): List<T>

List containing declarations with enum constant declarations satisfying the predicate.

withExpressionBody

fun <T : KoBodyProvider> List<T>.withExpressionBody(): List<T>

List containing declarations with expression body.

withExtension

fun <T : KoIsExtensionProvider> List<T>.withExtension(): List<T>

List containing declarations that are extensions.

fun <T : KoFileExtensionProvider> List<T>.withExtension(extensions: Collection<String>): List<T>

fun <T : KoFileExtensionProvider> List<T>.withExtension(extension: String, vararg extensions: String): List<T>

List containing files with extension.

withExternalDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withExternalDeclaration(predicate: (KoExternalDeclaration) -> Boolean? = null): List<T>

List containing declarations with the specified external declaration.

withExternalDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withExternalDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withExternalDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations with external declaration of.

withExternalParent

fun <T : KoExternalParentProvider> List<T>.withExternalParent(indirectParents: Boolean = false, predicate: (KoParentDeclaration) -> Boolean): List<T>

List containing declarations that have at least one external parent satisfying the provided predicate. The external parent is a parent defined outside the project codebase (defined inside external library).

withExternalParentNamed

fun <T : KoExternalParentProvider> List<T>.withExternalParentNamed(names: Collection<String>, indirectParents: Boolean = false): List<T>

fun <T : KoExternalParentProvider> List<T>.withExternalParentNamed(name: String, vararg names: String, indirectParents: Boolean = false): List<T>

List containing declarations that have at least one external parent with the specified name(s). The external parent is a parent defined outside the project codebase (defined inside external library).

withExternalParentOf

fun <T : KoExternalParentProvider> List<T>.withExternalParentOf(kClasses: Collection<KClass<*>>, indirectParents: Boolean = false): List<T>

fun <T : KoExternalParentProvider> List<T>.withExternalParentOf(kClass: KClass<*>, vararg kClasses: KClass<*>, indirectParents: Boolean = false): List<T>

List containing declarations that have at least one external parent of the specified KClass type. The external parent is a parent defined outside the project codebase (defined inside external library).

withExternalParents

fun <T : KoExternalParentProvider> List<T>.withExternalParents(indirectParents: Boolean = false): List<T>

List containing declarations with any external parent. The external parent is a parent defined outside the project codebase (defined inside external library).

fun <T : KoExternalParentProvider> List<T>.withExternalParents(indirectParents: Boolean = false, predicate: (List<KoParentDeclaration>) -> Boolean): List<T>

List containing declarations with external parent declarations satisfying the predicate. The external parent is a parent defined outside the project codebase (defined inside external library).

withExternalTypeDeclaration

fun <T : KoDeclarationCastProvider> List<T>.~~withExternalTypeDeclaration~~(predicate: (KoExternalDeclaration) -> Boolean? = null): List<T>

List containing declarations with the specified external declaration.

withExternalTypeDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.~~withExternalTypeDeclarationOf~~(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.~~withExternalTypeDeclarationOf~~(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations with external declaration of.

withFullyQualifiedName

fun <T : KoFullyQualifiedNameProvider> List<T>.withFullyQualifiedName(names: Collection<String>): List<T>

fun <T : KoFullyQualifiedNameProvider> List<T>.withFullyQualifiedName(name: String, vararg names: String): List<T>

List containing declarations with the fully qualified name.

withFunction

fun <T : KoFunctionProvider> List<T>.withFunction(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoFunctionDeclaration) -> Boolean): List<T>

List containing declarations that have at least one function satisfying the provided predicate.

withFunctionNamed

fun <T : KoFunctionProvider> List<T>.withFunctionNamed(names: Collection<String>, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

fun <T : KoFunctionProvider> List<T>.withFunctionNamed(name: String, vararg names: String, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations that have at least one function with the specified name(s).

withFunctions

fun <T : KoFunctionProvider> List<T>.withFunctions(includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations with any function.

fun <T : KoFunctionProvider> List<T>.withFunctions(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (List<KoFunctionDeclaration>) -> Boolean): List<T>

List containing declarations with function declarations satisfying the predicate.

withGeneric

fun <T : KoIsGenericProvider> List<T>.withGeneric(): List<T>

List containing declarations that are generic.

withGenericType

fun <T : KoIsGenericTypeProvider> List<T>.~~withGenericType~~(): List<T>

List containing declarations with generic type.

withGetter

fun <T : KoGetterProvider> List<T>.withGetter(): List<T>

List containing declarations with getter.

withImport

fun <T : KoImportProvider> List<T>.withImport(predicate: (KoImportDeclaration) -> Boolean): List<T>

List containing declarations that have at least one import satisfying the provided predicate.

withImportAlias

fun <T : KoImportAliasProvider> List<T>.withImportAlias(predicate: (KoImportAliasDeclaration) -> Boolean): List<T>

List containing declarations that have at least one import alias satisfying the provided predicate.

withImportAliasDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withImportAliasDeclaration(predicate: (KoImportAliasDeclaration) -> Boolean? = null): List<T>

List containing declarations with the specified import alias declaration.

withImportAliases

fun <T : KoImportAliasProvider> List<T>.withImportAliases(): List<T>

List containing declarations with any import alias.

fun <T : KoImportAliasProvider> List<T>.withImportAliases(predicate: (List<KoImportAliasDeclaration>) -> Boolean): List<T>

List containing declarations with import alias declarations satisfying the predicate.

withImportAliasNamed

fun <T : KoImportAliasProvider> List<T>.withImportAliasNamed(names: Collection<String>): List<T>

fun <T : KoImportAliasProvider> List<T>.withImportAliasNamed(name: String, vararg names: String): List<T>

List containing declarations that have at least one import alias with the specified name(s).

withImportNamed

fun <T : KoImportProvider> List<T>.withImportNamed(names: Collection<String>): List<T>

fun <T : KoImportProvider> List<T>.withImportNamed(name: String, vararg names: String): List<T>

List containing declarations that have at least one import with the specified name(s).

withImports

fun <T : KoImportProvider> List<T>.withImports(): List<T>

List containing declarations with any import.

fun <T : KoImportProvider> List<T>.withImports(predicate: (List<KoImportDeclaration>) -> Boolean): List<T>

List containing declarations with import declarations satisfying the predicate.

withInitBlock

fun <T : KoInitBlockProvider> List<T>.withInitBlock(predicate: (KoInitBlockDeclaration) -> Boolean): List<T>

List containing declarations that have at least one init block satisfying the provided predicate.

withInitBlocks

fun <T : KoInitBlockProvider> List<T>.withInitBlocks(): List<T>

List containing declarations that have init block(s).

fun <T : KoInitBlockProvider> List<T>.withInitBlocks(predicate: (List<KoInitBlockDeclaration>) -> Boolean): List<T>

List containing declarations with init block declarations satisfying the predicate.

withInitialized

fun <T : KoIsInitializedProvider> List<T>.withInitialized(): List<T>

List containing declarations that have been initialized.

withInterface

fun <T : KoInterfaceProvider> List<T>.withInterface(includeNested: Boolean = true, predicate: (KoInterfaceDeclaration) -> Boolean): List<T>

List containing declarations that have at least one interface satisfying the provided predicate.

withInterfaceDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withInterfaceDeclaration(predicate: (KoInterfaceDeclaration) -> Boolean? = null): List<T>

List containing declarations with the specified interface declaration.

withInterfaceDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withInterfaceDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withInterfaceDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations with interface declaration of.

withInterfaceNamed

fun <T : KoInterfaceProvider> List<T>.withInterfaceNamed(names: Collection<String>, includeNested: Boolean = true): List<T>

fun <T : KoInterfaceProvider> List<T>.withInterfaceNamed(name: String, vararg names: String, includeNested: Boolean = true): List<T>

List containing declarations that have at least one interface with the specified name(s).

withInterfaceOrObject

fun <T : KoInterfaceAndObjectProvider> List<T>.withInterfaceOrObject(includeNested: Boolean = true, predicate: (KoInterfaceAndObjectDeclaration) -> Boolean): List<T>

List containing declarations that have at least one interface or object satisfying the provided predicate.

withInterfaceOrObjectDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withInterfaceOrObjectDeclaration(predicate: (KoInterfaceAndObjectDeclaration) -> Boolean? = null): List<T>

List containing declarations with the specified interface or object declaration.

withInterfaceOrObjectDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withInterfaceOrObjectDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withInterfaceOrObjectDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations with interface or object declaration of.

withInterfaceOrObjectNamed

fun <T : KoInterfaceAndObjectProvider> List<T>.withInterfaceOrObjectNamed(names: Collection<String>, includeNested: Boolean = true): List<T>

fun <T : KoInterfaceAndObjectProvider> List<T>.withInterfaceOrObjectNamed(name: String, vararg names: String, includeNested: Boolean = true): List<T>

List containing declarations that have at least one interface or object with the specified name(s).

withInterfaces

fun <T : KoInterfaceProvider> List<T>.withInterfaces(includeNested: Boolean = true): List<T>

List containing declarations with any interface.

fun <T : KoInterfaceProvider> List<T>.withInterfaces(includeNested: Boolean = true, predicate: (List<KoInterfaceDeclaration>) -> Boolean): List<T>

List containing declarations with interface declarations satisfying the predicate.

withInterfacesAndObjects

fun <T : KoInterfaceAndObjectProvider> List<T>.withInterfacesAndObjects(includeNested: Boolean = true): List<T>

List containing declarations with any interface or object.

fun <T : KoInterfaceAndObjectProvider> List<T>.withInterfacesAndObjects(includeNested: Boolean = true, predicate: (List<KoInterfaceAndObjectDeclaration>) -> Boolean): List<T>

List containing declarations with interfaces and objects declarations satisfying the predicate.

withKDoc

fun <T : KoKDocProvider> List<T>.withKDoc(): List<T>

List containing declarations with KDoc.

withKotlinBasicTypeDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withKotlinBasicTypeDeclaration(predicate: (KoKotlinTypeDeclaration) -> Boolean? = null): List<T>

List containing declarations with the specified kotlin basic type declaration.

withKotlinBasicTypeDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withKotlinBasicTypeDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withKotlinBasicTypeDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations with kotlin basic type declaration of.

withKotlinCollectionTypeDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withKotlinCollectionTypeDeclaration(predicate: (KoKotlinTypeDeclaration) -> Boolean? = null): List<T>

List containing declarations with the specified kotlin collection type declaration.

withKotlinCollectionTypeDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withKotlinCollectionTypeDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withKotlinCollectionTypeDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations with kotlin collection type declaration of.

withKotlinTypeDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withKotlinTypeDeclaration(predicate: (KoKotlinTypeDeclaration) -> Boolean? = null): List<T>

List containing declarations with the specified kotlin type declaration.

withKotlinTypeDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withKotlinTypeDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withKotlinTypeDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations with kotlin type declaration of.

withLocalClass

fun <T : KoLocalClassProvider> List<T>.withLocalClass(predicate: (KoClassDeclaration) -> Boolean): List<T>

List containing declarations that have at least one local class satisfying the provided predicate.

withLocalClasses

fun <T : KoLocalClassProvider> List<T>.withLocalClasses(): List<T>

List containing declarations with any local class.

fun <T : KoLocalClassProvider> List<T>.withLocalClasses(predicate: (List<KoClassDeclaration>) -> Boolean): List<T>

List containing declarations with local class declarations satisfying the predicate.

withLocalClassNamed

fun <T : KoLocalClassProvider> List<T>.withLocalClassNamed(names: Collection<String>): List<T>

fun <T : KoLocalClassProvider> List<T>.withLocalClassNamed(name: String, vararg names: String): List<T>

List containing declarations that have at least one local class with the specified name(s).

withLocalDeclaration

fun <T : KoLocalDeclarationProvider> List<T>.withLocalDeclaration(predicate: (KoBaseDeclaration) -> Boolean): List<T>

List containing declarations that have at least one local declaration satisfying the provided predicate.

withLocalDeclarations

fun <T : KoLocalDeclarationProvider> List<T>.withLocalDeclarations(): List<T>

List containing declarations with any local declaration.

fun <T : KoLocalDeclarationProvider> List<T>.withLocalDeclarations(predicate: (List<KoBaseDeclaration>) -> Boolean): List<T>

List containing declarations with local declarations satisfying the predicate.

withLocalFunction

fun <T : KoLocalFunctionProvider> List<T>.withLocalFunction(predicate: (KoFunctionDeclaration) -> Boolean): List<T>

List containing declarations that have at least one local function satisfying the provided predicate.

withLocalFunctionNamed

fun <T : KoLocalFunctionProvider> List<T>.withLocalFunctionNamed(names: Collection<String>): List<T>

fun <T : KoLocalFunctionProvider> List<T>.withLocalFunctionNamed(name: String, vararg names: String): List<T>

List containing declarations that have at least one local function with the specified name(s).

withLocalFunctions

fun <T : KoLocalFunctionProvider> List<T>.withLocalFunctions(): List<T>

List containing declarations with any local function.

fun <T : KoLocalFunctionProvider> List<T>.withLocalFunctions(predicate: (List<KoFunctionDeclaration>) -> Boolean): List<T>

List containing declarations with local function declarations satisfying the predicate.

withMatchingPackage

fun <T : KoHasPackageProvider> List<T>.withMatchingPackage(): List<T>

List containing declarations with a matching package.

withMatchingPath

fun <T : KoPackageMatchingPathProvider> List<T>.withMatchingPath(): List<T>

List containing declarations with a matching path.

withModule

fun <T : KoModuleProvider> List<T>.withModule(names: Collection<String>): List<T>

fun <T : KoModuleProvider> List<T>.withModule(name: String, vararg names: String): List<T>

List containing declarations with module.

withMutableType

fun <T : KoIsMutableTypeProvider> List<T>.withMutableType(): List<T>

Returns a list of declarations with mutable types.

withName

fun <T : KoNameProvider> List<T>.withName(vararg names: String): List<T>

fun <T : KoNameProvider> List<T>.withName(names: Collection<String>): List<T>

List containing declarations with name.

fun <T : KoNameProvider> List<T>.withName(predicate: (String) -> Boolean): List<T>

List containing declarations that have a name matching the provided predicate.

withNameContaining

fun <T : KoNameProvider> List<T>.withNameContaining(texts: Collection<String>): List<T>

fun <T : KoNameProvider> List<T>.withNameContaining(text: String, vararg texts: String): List<T>

List containing declarations with name containing any of the specified String.

withNameEndingWith

fun <T : KoNameProvider> List<T>.withNameEndingWith(suffixes: Collection<String>): List<T>

fun <T : KoNameProvider> List<T>.withNameEndingWith(suffix: String, vararg suffixes: String): List<T>

List containing declarations with name with any of the specified suffix.

withNameMatching

fun <T : KoNameProvider> List<T>.withNameMatching(regexes: Collection<Regex>): List<T>

fun <T : KoNameProvider> List<T>.withNameMatching(regex: Regex, vararg regexes: Regex): List<T>

List containing declarations with name matching any of the specified regex.

withNameStartingWith

fun <T : KoNameProvider> List<T>.withNameStartingWith(prefixes: Collection<String>): List<T>

fun <T : KoNameProvider> List<T>.withNameStartingWith(prefix: String, vararg prefixes: String): List<T>

List containing declarations with name with any of the specified prefix.

withNullable

fun <T : KoIsNullableProvider> List<T>.withNullable(): List<T>

List containing declarations with nullable type.

withNullableType

fun <T : KoNullableProvider> List<T>.~~withNullableType~~(): List<T>

List containing declarations with nullable type.

withObject

fun <T : KoObjectProvider> List<T>.withObject(includeNested: Boolean = true, predicate: (KoObjectDeclaration) -> Boolean): List<T>

List containing declarations that have at least one object satisfying the provided predicate.

withObjectDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withObjectDeclaration(predicate: (KoObjectDeclaration) -> Boolean? = null): List<T>

List containing declarations with the specified object declaration.

withObjectDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withObjectDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withObjectDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations with object declaration of.

withObjectNamed

fun <T : KoObjectProvider> List<T>.withObjectNamed(names: Collection<String>, includeNested: Boolean = true): List<T>

fun <T : KoObjectProvider> List<T>.withObjectNamed(name: String, vararg names: String, includeNested: Boolean = true): List<T>

List containing declarations that have at least one object with the specified name(s).

withObjects

fun <T : KoObjectProvider> List<T>.withObjects(includeNested: Boolean = true): List<T>

List containing declarations with any object.

fun <T : KoObjectProvider> List<T>.withObjects(includeNested: Boolean = true, predicate: (List<KoObjectDeclaration>) -> Boolean): List<T>

List containing declarations with object declarations satisfying the predicate.

withoutAbsolutePath

fun <T : KoPathProvider> List<T>.withoutAbsolutePath(paths: Collection<String>): List<T>

fun <T : KoPathProvider> List<T>.withoutAbsolutePath(paths: List<String>): List<T>

fun <T : KoPathProvider> List<T>.withoutAbsolutePath(path: String, vararg paths: String): List<T>

List containing declarations without absolute path.

withoutAlias

fun <T : KoAliasProvider> List<T>.withoutAlias(predicate: (KoImportAliasDeclaration) -> Boolean? = null): List<T>

List containing declarations without the specified import alias.

withoutAllAnnotations

fun <T : KoAnnotationProvider> List<T>.withoutAllAnnotations(predicate: (KoAnnotationDeclaration) -> Boolean): List<T>

List containing declarations that have at least one annotation not satisfying the provided predicate.

withoutAllAnnotationsNamed

fun <T : KoAnnotationProvider> List<T>.withoutAllAnnotationsNamed(names: Collection<String>): List<T>

fun <T : KoAnnotationProvider> List<T>.withoutAllAnnotationsNamed(name: String, vararg names: String): List<T>

List containing declarations without all specified annotations.

withoutAllAnnotationsOf

fun <T : KoAnnotationProvider> List<T>.withoutAllAnnotationsOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoAnnotationProvider> List<T>.withoutAllAnnotationsOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without all specified KClass type annotations.

withoutAllArguments

fun <T : KoArgumentProvider> List<T>.withoutAllArguments(predicate: (KoArgumentDeclaration) -> Boolean): List<T>

List containing declarations that have at least one argument not satisfying the provided predicate.

withoutAllArgumentsNamed

fun <T : KoArgumentProvider> List<T>.withoutAllArgumentsNamed(names: Collection<String>): List<T>

fun <T : KoArgumentProvider> List<T>.withoutAllArgumentsNamed(name: String, vararg names: String): List<T>

List containing declarations without all specified arguments.

withoutAllChildren

fun <T : KoChildProvider> List<T>.withoutAllChildren(indirectChildren: Boolean = false, predicate: (KoChildDeclaration) -> Boolean): List<T>

List containing declarations that have at least one child not satisfying the provided predicate.

withoutAllChildrenNamed

fun <T : KoChildProvider> List<T>.withoutAllChildrenNamed(names: Collection<String>, indirectChildren: Boolean = false): List<T>

fun <T : KoChildProvider> List<T>.withoutAllChildrenNamed(name: String, vararg names: String, indirectChildren: Boolean = false): List<T>

List containing declarations without all specified children.

withoutAllChildrenOf

fun <T : KoChildProvider> List<T>.withoutAllChildrenOf(kClasses: Collection<KClass<*>>, indirectChildren: Boolean = false): List<T>

fun <T : KoChildProvider> List<T>.withoutAllChildrenOf(kClass: KClass<*>, vararg kClasses: KClass<*>, indirectChildren: Boolean = false): List<T>

List containing declarations without all specified KClass type children.

withoutAllClasses

fun <T : KoClassProvider> List<T>.withoutAllClasses(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoClassDeclaration) -> Boolean): List<T>

List containing declarations that have at least one class not satisfying the provided predicate.

withoutAllClassesAndInterfaces

fun <T : KoClassAndInterfaceProvider> List<T>.withoutAllClassesAndInterfaces(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoClassAndInterfaceDeclaration) -> Boolean): List<T>

List containing declarations that have at least one class or interface not satisfying the provided predicate.

withoutAllClassesAndInterfacesAndObjects

fun <T : KoClassAndInterfaceAndObjectProvider> List<T>.withoutAllClassesAndInterfacesAndObjects(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoClassAndInterfaceAndObjectDeclaration) -> Boolean): List<T>

List containing declarations that have at least one class, interface or object not satisfying the provided predicate.

withoutAllClassesAndInterfacesAndObjectsNamed

fun <T : KoClassAndInterfaceAndObjectProvider> List<T>.withoutAllClassesAndInterfacesAndObjectsNamed(names: Collection<String>, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

fun <T : KoClassAndInterfaceAndObjectProvider> List<T>.withoutAllClassesAndInterfacesAndObjectsNamed(name: String, vararg names: String, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations without all specified classes, interfaces and objects.

withoutAllClassesAndInterfacesNamed

fun <T : KoClassAndInterfaceProvider> List<T>.withoutAllClassesAndInterfacesNamed(names: Collection<String>, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

fun <T : KoClassAndInterfaceProvider> List<T>.withoutAllClassesAndInterfacesNamed(name: String, vararg names: String, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations without all specified classes and interfaces.

withoutAllClassesAndObjects

fun <T : KoClassAndObjectProvider> List<T>.withoutAllClassesAndObjects(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoClassAndObjectDeclaration) -> Boolean): List<T>

List containing declarations that have at least one class or object not satisfying the provided predicate.

withoutAllClassesAndObjectsNamed

fun <T : KoClassAndObjectProvider> List<T>.withoutAllClassesAndObjectsNamed(names: Collection<String>, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

fun <T : KoClassAndObjectProvider> List<T>.withoutAllClassesAndObjectsNamed(name: String, vararg names: String, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations without all specified classes and objects.

withoutAllClassesNamed

fun <T : KoClassProvider> List<T>.withoutAllClassesNamed(names: Collection<String>, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

fun <T : KoClassProvider> List<T>.withoutAllClassesNamed(name: String, vararg names: String, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations without all specified classes.

withoutAllConstructors

fun <T : KoConstructorProvider> List<T>.withoutAllConstructors(predicate: (KoConstructorDeclaration) -> Boolean): List<T>

List containing declarations that have at least one constructor not satisfying the provided predicate.

withoutAllDeclarations

fun <T : KoDeclarationProvider> List<T>.withoutAllDeclarations(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoBaseDeclaration) -> Boolean): List<T>

List containing declarations that have at least one declaration not satisfying the provided predicate.

withoutAllEnumConstants

fun <T : KoEnumConstantProvider> List<T>.withoutAllEnumConstants(predicate: (KoEnumConstantDeclaration) -> Boolean): List<T>

List containing declarations that have at least one enum constant not satisfying the provided predicate.

withoutAllEnumConstantsNamed

fun <T : KoEnumConstantProvider> List<T>.withoutAllEnumConstantsNamed(names: Collection<String>): List<T>

fun <T : KoEnumConstantProvider> List<T>.withoutAllEnumConstantsNamed(name: String, vararg names: String): List<T>

List containing declarations without all specified enum constants.

withoutAllExternalParents

fun <T : KoExternalParentProvider> List<T>.withoutAllExternalParents(indirectParents: Boolean = false, predicate: (KoParentDeclaration) -> Boolean): List<T>

List containing declarations that have at least one external parent not satisfying the provided predicate. The external parent is a parent defined outside the project codebase (defined inside external library).

withoutAllExternalParentsNamed

fun <T : KoExternalParentProvider> List<T>.withoutAllExternalParentsNamed(names: Collection<String>, indirectParents: Boolean = false): List<T>

fun <T : KoExternalParentProvider> List<T>.withoutAllExternalParentsNamed(name: String, vararg names: String, indirectParents: Boolean = false): List<T>

List containing declarations without all specified external parents. The external parent is a parent defined outside the project codebase (defined inside external library).

withoutAllExternalParentsOf

fun <T : KoExternalParentProvider> List<T>.withoutAllExternalParentsOf(kClasses: Collection<KClass<*>>, indirectParents: Boolean = false): List<T>

fun <T : KoExternalParentProvider> List<T>.withoutAllExternalParentsOf(kClass: KClass<*>, vararg kClasses: KClass<*>, indirectParents: Boolean = false): List<T>

List containing declarations without all specified KClass type external parents. The external parent is a parent defined outside the project codebase (defined inside external library).

withoutAllFunctions

fun <T : KoFunctionProvider> List<T>.withoutAllFunctions(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoFunctionDeclaration) -> Boolean): List<T>

List containing declarations that have at least one function not satisfying the provided predicate.

withoutAllFunctionsNamed

fun <T : KoFunctionProvider> List<T>.withoutAllFunctionsNamed(names: Collection<String>, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

fun <T : KoFunctionProvider> List<T>.withoutAllFunctionsNamed(name: String, vararg names: String, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations without all specified functions.

withoutAllImportAliases

fun <T : KoImportAliasProvider> List<T>.withoutAllImportAliases(predicate: (KoImportAliasDeclaration) -> Boolean): List<T>

List containing declarations that have at least one import alias not satisfying the provided predicate.

withoutAllImportAliasesNamed

fun <T : KoImportAliasProvider> List<T>.withoutAllImportAliasesNamed(names: Collection<String>): List<T>

fun <T : KoImportAliasProvider> List<T>.withoutAllImportAliasesNamed(name: String, vararg names: String): List<T>

List containing declarations without all specified import aliases.

withoutAllImports

fun <T : KoImportProvider> List<T>.withoutAllImports(predicate: (KoImportDeclaration) -> Boolean): List<T>

List containing declarations that have at least one import not satisfying the provided predicate.

withoutAllImportsNamed

fun <T : KoImportProvider> List<T>.withoutAllImportsNamed(names: Collection<String>): List<T>

fun <T : KoImportProvider> List<T>.withoutAllImportsNamed(name: String, vararg names: String): List<T>

List containing declarations without all specified imports.

withoutAllInitBlocks

fun <T : KoInitBlockProvider> List<T>.withoutAllInitBlocks(predicate: (KoInitBlockDeclaration) -> Boolean): List<T>

List containing declarations that have at least one init block not satisfying the provided predicate.

withoutAllInterfaces

fun <T : KoInterfaceProvider> List<T>.withoutAllInterfaces(includeNested: Boolean = true, predicate: (KoInterfaceDeclaration) -> Boolean): List<T>

List containing declarations that have at least one interface not satisfying the provided predicate.

withoutAllInterfacesAndObjects

fun <T : KoInterfaceAndObjectProvider> List<T>.withoutAllInterfacesAndObjects(includeNested: Boolean = true, predicate: (KoInterfaceAndObjectDeclaration) -> Boolean): List<T>

List containing declarations that have at least one interface or object not satisfying the provided predicate.

withoutAllInterfacesAndObjectsNamed

fun <T : KoInterfaceAndObjectProvider> List<T>.withoutAllInterfacesAndObjectsNamed(names: Collection<String>, includeNested: Boolean = true): List<T>

fun <T : KoInterfaceAndObjectProvider> List<T>.withoutAllInterfacesAndObjectsNamed(name: String, vararg names: String, includeNested: Boolean = true): List<T>

List containing declarations without all specified interfaces and objects.

withoutAllInterfacesNamed

fun <T : KoInterfaceProvider> List<T>.withoutAllInterfacesNamed(names: Collection<String>, includeNested: Boolean = true): List<T>

fun <T : KoInterfaceProvider> List<T>.withoutAllInterfacesNamed(name: String, vararg names: String, includeNested: Boolean = true): List<T>

List containing declarations without all specified interfaces.

withoutAllLocalClasses

fun <T : KoLocalClassProvider> List<T>.withoutAllLocalClasses(predicate: (KoClassDeclaration) -> Boolean): List<T>

List containing declarations that have at least one local class not satisfying the provided predicate.

withoutAllLocalClassesNamed

fun <T : KoLocalClassProvider> List<T>.withoutAllLocalClassesNamed(names: Collection<String>): List<T>

fun <T : KoLocalClassProvider> List<T>.withoutAllLocalClassesNamed(name: String, vararg names: String): List<T>

List containing declarations without all specified local classes.

withoutAllLocalDeclarations

fun <T : KoLocalDeclarationProvider> List<T>.withoutAllLocalDeclarations(predicate: (KoBaseDeclaration) -> Boolean): List<T>

List containing declarations that have at least one local declaration not satisfying the provided predicate.

withoutAllLocalFunctions

fun <T : KoLocalFunctionProvider> List<T>.withoutAllLocalFunctions(predicate: (KoFunctionDeclaration) -> Boolean): List<T>

List containing declarations that have at least one local function not satisfying the provided predicate.

withoutAllLocalFunctionsNamed

fun <T : KoLocalFunctionProvider> List<T>.withoutAllLocalFunctionsNamed(names: Collection<String>): List<T>

fun <T : KoLocalFunctionProvider> List<T>.withoutAllLocalFunctionsNamed(name: String, vararg names: String): List<T>

List containing declarations without all specified local functions.

withoutAllObjects

fun <T : KoObjectProvider> List<T>.withoutAllObjects(includeNested: Boolean = true, predicate: (KoObjectDeclaration) -> Boolean): List<T>

List containing declarations that have at least one object not satisfying the provided predicate.

withoutAllObjectsNamed

fun <T : KoObjectProvider> List<T>.withoutAllObjectsNamed(names: Collection<String>, includeNested: Boolean = true): List<T>

List containing declarations without any of specified objects.

fun <T : KoObjectProvider> List<T>.withoutAllObjectsNamed(name: String, vararg names: String, includeNested: Boolean = true): List<T>

List containing declarations without all specified objects.

withoutAllParameters

fun <T : KoFunctionTypeDeclarationProvider> List<T>.withoutAllParameters(predicate: (KoParameterDeclaration) -> Boolean): List<T>

Filters the list by excluding functions where all parameters match the given predicate.

fun <T : KoParametersProvider> List<T>.withoutAllParameters(predicate: (KoParameterDeclaration) -> Boolean): List<T>

List containing declarations that have at least one parameter not satisfying the provided predicate.

withoutAllParametersNamed

fun <T : KoParametersProvider> List<T>.withoutAllParametersNamed(names: Collection<String>): List<T>

fun <T : KoParametersProvider> List<T>.withoutAllParametersNamed(name: String, vararg names: String): List<T>

List containing declarations without all specified parameters.

withoutAllParameterTypes

fun <T : KoFunctionTypeDeclarationProvider> List<T>.~~withoutAllParameterTypes~~(predicate: (KoParameterDeclaration) -> Boolean): List<T>

Filters the list by excluding functions where all parameter types match the given predicate.

withoutAllParentClasses

fun <T : KoParentClassProvider> List<T>.withoutAllParentClasses(indirectParents: Boolean = false, predicate: (KoParentDeclaration) -> Boolean): List<T>

List containing declarations that have at least one parent class not satisfying the provided predicate.

withoutAllParentClassesNamed

fun <T : KoParentClassProvider> List<T>.withoutAllParentClassesNamed(names: Collection<String>, indirectParents: Boolean = false): List<T>

fun <T : KoParentClassProvider> List<T>.withoutAllParentClassesNamed(name: String, vararg names: String, indirectParents: Boolean = false): List<T>

List containing declarations without all specified parent classes.

withoutAllParentClassesOf

fun <T : KoParentClassProvider> List<T>.withoutAllParentClassesOf(kClasses: Collection<KClass<*>>, indirectParents: Boolean = false): List<T>

fun <T : KoParentClassProvider> List<T>.withoutAllParentClassesOf(kClass: KClass<*>, vararg kClasses: KClass<*>, indirectParents: Boolean = false): List<T>

List containing declarations without all specified KClass type parent classes.

withoutAllParentInterfaces

fun <T : KoParentInterfaceProvider> List<T>.withoutAllParentInterfaces(indirectParents: Boolean = false, predicate: (KoParentDeclaration) -> Boolean): List<T>

List containing declarations that have at least one parent interface not satisfying the provided predicate.

withoutAllParentInterfacesNamed

fun <T : KoParentInterfaceProvider> List<T>.withoutAllParentInterfacesNamed(names: Collection<String>, indirectParents: Boolean = false): List<T>

fun <T : KoParentInterfaceProvider> List<T>.withoutAllParentInterfacesNamed(name: String, vararg names: String, indirectParents: Boolean = false): List<T>

List containing declarations without all specified parent interfaces.

withoutAllParentInterfacesOf

fun <T : KoParentInterfaceProvider> List<T>.withoutAllParentInterfacesOf(kClasses: Collection<KClass<*>>, indirectParents: Boolean = false): List<T>

fun <T : KoParentInterfaceProvider> List<T>.withoutAllParentInterfacesOf(kClass: KClass<*>, vararg kClasses: KClass<*>, indirectParents: Boolean = false): List<T>

List containing declarations without all specified KClass type parent interfaces.

withoutAllParents

fun <T : KoParentProvider> List<T>.withoutAllParents(indirectParents: Boolean = false, predicate: (KoParentDeclaration) -> Boolean): List<T>

List containing declarations that have at least one parent not satisfying the provided predicate.

withoutAllParentsNamed

fun <T : KoParentProvider> List<T>.withoutAllParentsNamed(names: Collection<String>, indirectParents: Boolean = false): List<T>

fun <T : KoParentProvider> List<T>.withoutAllParentsNamed(name: String, vararg names: String, indirectParents: Boolean = false): List<T>

List containing declarations without all specified parents.

withoutAllParentsOf

fun <T : KoParentProvider> List<T>.withoutAllParentsOf(kClasses: Collection<KClass<*>>, indirectParents: Boolean = false): List<T>

fun <T : KoParentProvider> List<T>.withoutAllParentsOf(kClass: KClass<*>, vararg kClasses: KClass<*>, indirectParents: Boolean = false): List<T>

List containing declarations without all specified KClass type parents.

withoutAllProperties

fun <T : KoPropertyProvider> List<T>.withoutAllProperties(includeNested: Boolean = true, predicate: (KoPropertyDeclaration) -> Boolean): List<T>

List containing declarations that have at least one property not satisfying the provided predicate.

withoutAllPropertiesNamed

fun <T : KoPropertyProvider> List<T>.withoutAllPropertiesNamed(names: Collection<String>, includeNested: Boolean = true): List<T>

fun <T : KoPropertyProvider> List<T>.withoutAllPropertiesNamed(name: String, vararg names: String, includeNested: Boolean = true): List<T>

List containing declarations without all specified properties.

withoutAllSecondaryConstructors

fun <T : KoSecondaryConstructorsProvider> List<T>.withoutAllSecondaryConstructors(predicate: (KoSecondaryConstructorDeclaration) -> Boolean): List<T>

List containing declarations that have at least one secondary constructor not satisfying the provided predicate.

withoutAllTypeAliases

fun <T : KoTypeAliasProvider> List<T>.withoutAllTypeAliases(predicate: (KoTypeAliasDeclaration) -> Boolean): List<T>

List containing declarations that have at least one type alias not satisfying the provided predicate.

withoutAllTypeAliasesNamed

fun <T : KoTypeAliasProvider> List<T>.withoutAllTypeAliasesNamed(names: Collection<String>): List<T>

fun <T : KoTypeAliasProvider> List<T>.withoutAllTypeAliasesNamed(name: String, vararg names: String): List<T>

List containing declarations without all specified type aliases.

withoutAllTypeArguments

fun <T : KoTypeArgumentProvider> List<T>.withoutAllTypeArguments(predicate: (KoTypeArgumentDeclaration) -> Boolean): List<T>

List containing declarations that have at least one type argument not satisfying the provided predicate.

withoutAllTypeArgumentsNamed

fun <T : KoTypeArgumentProvider> List<T>.withoutAllTypeArgumentsNamed(names: Collection<String>): List<T>

fun <T : KoTypeArgumentProvider> List<T>.withoutAllTypeArgumentsNamed(name: String, vararg names: String): List<T>

List containing declarations without all specified type arguments.

withoutAllTypeParameters

fun <T : KoTypeParameterProvider> List<T>.withoutAllTypeParameters(predicate: (KoTypeParameterDeclaration) -> Boolean): List<T>

List containing declarations that have at least one type parameter not satisfying the provided predicate.

withoutAllTypeParametersNamed

fun <T : KoTypeParameterProvider> List<T>.withoutAllTypeParametersNamed(names: Collection<String>): List<T>

fun <T : KoTypeParameterProvider> List<T>.withoutAllTypeParametersNamed(name: String, vararg names: String): List<T>

List containing declarations without all specified type parameters.

withoutAllUpperBounds

fun <T : KoUpperBoundsProvider> List<T>.withoutAllUpperBounds(predicate: (KoTypeDeclaration) -> Boolean): List<T>

List containing declarations that have at least one upper bound not satisfying the provided predicate.

withoutAllUpperBoundsNamed

fun <T : KoUpperBoundsProvider> List<T>.withoutAllUpperBoundsNamed(names: Collection<String>): List<T>

fun <T : KoUpperBoundsProvider> List<T>.withoutAllUpperBoundsNamed(name: String, vararg names: String): List<T>

List containing declarations without all specified upper bounds.

withoutAllVariables

fun <T : KoVariableProvider> List<T>.withoutAllVariables(predicate: (KoVariableDeclaration) -> Boolean): List<T>

List containing declarations that have at least one variable not satisfying the provided predicate.

withoutAllVariablesNamed

fun <T : KoVariableProvider> List<T>.withoutAllVariablesNamed(names: Collection<String>): List<T>

fun <T : KoVariableProvider> List<T>.withoutAllVariablesNamed(name: String, vararg names: String): List<T>

List containing declarations without all specified variables.

withoutAnnotation

fun <T : KoAnnotationProvider> List<T>.withoutAnnotation(predicate: (KoAnnotationDeclaration) -> Boolean): List<T>

List containing declarations that not have annotation satisfying the provided predicate.

withoutAnnotationNamed

fun <T : KoAnnotationProvider> List<T>.withoutAnnotationNamed(names: Collection<String>): List<T>

fun <T : KoAnnotationProvider> List<T>.withoutAnnotationNamed(name: String, vararg names: String): List<T>

List containing declarations without any of specified annotations.

withoutAnnotationOf

fun <T : KoAnnotationProvider> List<T>.withoutAnnotationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoAnnotationProvider> List<T>.withoutAnnotationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without any annotation of the specified KClass type.

withoutAnnotations

fun <T : KoAnnotationProvider> List<T>.withoutAnnotations(): List<T>

List containing declarations with no annotation.

fun <T : KoAnnotationProvider> List<T>.withoutAnnotations(predicate: (List<KoAnnotationDeclaration>) -> Boolean): List<T>

List containing declarations without annotation declarations satisfying the predicate.

withoutArgument

fun <T : KoArgumentProvider> List<T>.withoutArgument(predicate: (KoArgumentDeclaration) -> Boolean): List<T>

List containing declarations that not have argument satisfying the provided predicate.

withoutArgumentNamed

fun <T : KoArgumentProvider> List<T>.withoutArgumentNamed(names: Collection<String>): List<T>

fun <T : KoArgumentProvider> List<T>.withoutArgumentNamed(name: String, vararg names: String): List<T>

List containing declarations without any of specified arguments.

withoutArguments

fun <T : KoArgumentProvider> List<T>.withoutArguments(): List<T>

List containing declarations with no arguments.

fun <T : KoArgumentProvider> List<T>.withoutArguments(predicate: (List<KoArgumentDeclaration>) -> Boolean): List<T>

List containing declarations without argument declarations satisfying the predicate.

withoutBareSourceType

fun <T : KoSourceTypeProvider> List<T>.withoutBareSourceType(names: Collection<String>): List<T>

fun <T : KoSourceTypeProvider> List<T>.withoutBareSourceType(name: String, vararg names: String): List<T>

List containing declarations without bare source type.

withoutBareSourceTypeOf

fun <T : KoSourceTypeProvider> List<T>.withoutBareSourceTypeOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoSourceTypeProvider> List<T>.withoutBareSourceTypeOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without bare source type of.

withoutBlockBody

fun <T : KoBodyProvider> List<T>.withoutBlockBody(): List<T>

List containing declarations without block body.

withoutChild

fun <T : KoChildProvider> List<T>.withoutChild(indirectChildren: Boolean = false, predicate: (KoChildDeclaration) -> Boolean): List<T>

List containing declarations that not have child satisfying the provided predicate.

withoutChildNamed

fun <T : KoChildProvider> List<T>.withoutChildNamed(names: Collection<String>, indirectChildren: Boolean = false): List<T>

fun <T : KoChildProvider> List<T>.withoutChildNamed(name: String, vararg names: String, indirectChildren: Boolean = false): List<T>

List containing declarations without any of specified children.

withoutChildOf

fun <T : KoChildProvider> List<T>.withoutChildOf(kClasses: Collection<KClass<*>>, indirectChildren: Boolean = false): List<T>

fun <T : KoChildProvider> List<T>.withoutChildOf(kClass: KClass<*>, vararg kClasses: KClass<*>, indirectChildren: Boolean = false): List<T>

List containing declarations without any child of the specified KClass type.

withoutChildren

fun <T : KoChildProvider> List<T>.withoutChildren(indirectChildren: Boolean = false): List<T>

List containing declarations with no child - class does not extend any class and does not implement any interface.

fun <T : KoChildProvider> List<T>.withoutChildren(indirectChildren: Boolean = false, predicate: (List<KoChildDeclaration>) -> Boolean): List<T>

List containing declarations without child declarations satisfying the predicate.

withoutClass

fun <T : KoClassProvider> List<T>.withoutClass(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoClassDeclaration) -> Boolean): List<T>

List containing declarations that not have class satisfying the provided predicate.

withoutClassDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withoutClassDeclaration(predicate: (KoClassDeclaration) -> Boolean? = null): List<T>

List containing declarations without the specified class declaration.

withoutClassDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withoutClassDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withoutClassDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without class declaration of.

withoutClasses

fun <T : KoClassProvider> List<T>.withoutClasses(includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations with no classes.

fun <T : KoClassProvider> List<T>.withoutClasses(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (List<KoClassDeclaration>) -> Boolean): List<T>

List containing declarations without class declarations satisfying the predicate.

withoutClassesAndInterfaces

fun <T : KoClassAndInterfaceProvider> List<T>.withoutClassesAndInterfaces(includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations with no classes and interfaces.

fun <T : KoClassAndInterfaceProvider> List<T>.withoutClassesAndInterfaces(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (List<KoClassAndInterfaceDeclaration>) -> Boolean): List<T>

List containing declarations without classes and interfaces declarations satisfying the predicate.

withoutClassesAndInterfacesAndObjects

fun <T : KoClassAndInterfaceAndObjectProvider> List<T>.withoutClassesAndInterfacesAndObjects(includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations with no classes, interfaces and objects.

fun <T : KoClassAndInterfaceAndObjectProvider> List<T>.withoutClassesAndInterfacesAndObjects(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (List<KoClassAndInterfaceAndObjectDeclaration>) -> Boolean): List<T>

List containing declarations without classes, interfaces and objects declarations satisfying the predicate.

withoutClassesAndObjects

fun <T : KoClassAndObjectProvider> List<T>.withoutClassesAndObjects(includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations with no classes and objects.

fun <T : KoClassAndObjectProvider> List<T>.withoutClassesAndObjects(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (List<KoClassAndObjectDeclaration>) -> Boolean): List<T>

List containing declarations without classes and objects declarations satisfying the predicate.

withoutClassNamed

fun <T : KoClassProvider> List<T>.withoutClassNamed(names: Collection<String>, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

fun <T : KoClassProvider> List<T>.withoutClassNamed(name: String, vararg names: String, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations without any of specified classes.

withoutClassOrInterface

fun <T : KoClassAndInterfaceProvider> List<T>.withoutClassOrInterface(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoClassAndInterfaceDeclaration) -> Boolean): List<T>

List containing declarations that not have class or interface satisfying the provided predicate.

withoutClassOrInterfaceDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withoutClassOrInterfaceDeclaration(predicate: (KoClassAndInterfaceDeclaration) -> Boolean? = null): List<T>

List containing declarations without the specified class or interface declaration.

withoutClassOrInterfaceDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withoutClassOrInterfaceDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withoutClassOrInterfaceDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without class or interface declaration of.

withoutClassOrInterfaceNamed

fun <T : KoClassAndInterfaceProvider> List<T>.withoutClassOrInterfaceNamed(names: Collection<String>, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

fun <T : KoClassAndInterfaceProvider> List<T>.withoutClassOrInterfaceNamed(name: String, vararg names: String, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations without any of specified classes and interfaces.

withoutClassOrInterfaceOrObject

fun <T : KoClassAndInterfaceAndObjectProvider> List<T>.withoutClassOrInterfaceOrObject(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoClassAndInterfaceAndObjectDeclaration) -> Boolean): List<T>

List containing declarations that not have class, interface or object satisfying the provided predicate.

withoutClassOrInterfaceOrObjectDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withoutClassOrInterfaceOrObjectDeclaration(predicate: (KoClassAndInterfaceAndObjectDeclaration) -> Boolean? = null): List<T>

List containing declarations without the specified class, interface or object declaration.

withoutClassOrInterfaceOrObjectDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withoutClassOrInterfaceOrObjectDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withoutClassOrInterfaceOrObjectDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without class, interface or object declaration of.

withoutClassOrInterfaceOrObjectNamed

fun <T : KoClassAndInterfaceAndObjectProvider> List<T>.withoutClassOrInterfaceOrObjectNamed(names: Collection<String>, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

fun <T : KoClassAndInterfaceAndObjectProvider> List<T>.withoutClassOrInterfaceOrObjectNamed(name: String, vararg names: String, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations without any of specified classes, interfaces and objects.

withoutClassOrObject

fun <T : KoClassAndObjectProvider> List<T>.withoutClassOrObject(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoClassAndObjectDeclaration) -> Boolean): List<T>

List containing declarations that not have class or object satisfying the provided predicate.

withoutClassOrObjectDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withoutClassOrObjectDeclaration(predicate: (KoClassAndObjectDeclaration) -> Boolean? = null): List<T>

List containing declarations without the specified class or object declaration.

withoutClassOrObjectDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withoutClassOrObjectDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withoutClassOrObjectDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without class or object declaration of.

withoutClassOrObjectNamed

fun <T : KoClassAndObjectProvider> List<T>.withoutClassOrObjectNamed(names: Collection<String>, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

fun <T : KoClassAndObjectProvider> List<T>.withoutClassOrObjectNamed(name: String, vararg names: String, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations without any of specified classes and objects.

withoutConstructor

fun <T : KoConstructorProvider> List<T>.withoutConstructor(predicate: (KoConstructorDeclaration) -> Boolean): List<T>

List containing declarations that not have constructor satisfying the provided predicate.

withoutConstructorDefined

fun <T : KoIsConstructorDefinedProvider> List<T>.withoutConstructorDefined(): List<T>

List containing declarations defined outside a constructor.

withoutConstructors

fun <T : KoConstructorProvider> List<T>.withoutConstructors(): List<T>

List containing declarations without constructor.

fun <T : KoConstructorProvider> List<T>.withoutConstructors(predicate: (List<KoConstructorDeclaration>) -> Boolean): List<T>

List containing declarations without constructor declarations satisfying the predicate.

withoutDeclaration

fun <T : KoDeclarationProvider> List<T>.withoutDeclaration(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoBaseDeclaration) -> Boolean): List<T>

List containing declarations that not have declaration satisfying the provided predicate.

withoutDeclarations

fun <T : KoDeclarationProvider> List<T>.withoutDeclarations(includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations with no declarations.

fun <T : KoDeclarationProvider> List<T>.withoutDeclarations(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (List<KoBaseDeclaration>) -> Boolean): List<T>

List containing declarations without declarations satisfying the predicate.

withoutDefaultValue

fun <T : KoDefaultValueProvider> List<T>.withoutDefaultValue(vararg values: String): List<T>

fun <T : KoDefaultValueProvider> List<T>.withoutDefaultValue(values: Collection<String>): List<T>

List containing declarations without default value.

withoutDelegate

fun <T : KoDelegateProvider> List<T>.withoutDelegate(vararg names: String): List<T>

fun <T : KoDelegateProvider> List<T>.withoutDelegate(names: Collection<String>): List<T>

List containing declarations without delegate with given name.

withoutEnumConstant

fun <T : KoEnumConstantProvider> List<T>.withoutEnumConstant(predicate: (KoEnumConstantDeclaration) -> Boolean): List<T>

List containing declarations that not have enum constant satisfying the provided predicate.

withoutEnumConstantNamed

fun <T : KoEnumConstantProvider> List<T>.withoutEnumConstantNamed(names: Collection<String>): List<T>

fun <T : KoEnumConstantProvider> List<T>.withoutEnumConstantNamed(name: String, vararg names: String): List<T>

List containing declarations without any of specified enum constants.

withoutEnumConstants

fun <T : KoEnumConstantProvider> List<T>.withoutEnumConstants(): List<T>

List containing declarations with no enum constant.

fun <T : KoEnumConstantProvider> List<T>.withoutEnumConstants(predicate: (List<KoEnumConstantDeclaration>) -> Boolean): List<T>

List containing declarations without enum constant declarations satisfying the predicate.

withoutExpressionBody

fun <T : KoBodyProvider> List<T>.withoutExpressionBody(): List<T>

List containing declarations without expression body.

withoutExtension

fun <T : KoIsExtensionProvider> List<T>.withoutExtension(): List<T>

List containing declarations that are not extensions.

fun <T : KoFileExtensionProvider> List<T>.withoutExtension(extensions: Collection<String>): List<T>

fun <T : KoFileExtensionProvider> List<T>.withoutExtension(extension: String, vararg extensions: String): List<T>

List containing files without extension.

withoutExternalDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withoutExternalDeclaration(predicate: (KoExternalDeclaration) -> Boolean? = null): List<T>

List containing declarations without the specified external declaration.

withoutExternalDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withoutExternalDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withoutExternalDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without external declaration of.

withoutExternalParent

fun <T : KoExternalParentProvider> List<T>.withoutExternalParent(indirectParents: Boolean = false, predicate: (KoParentDeclaration) -> Boolean): List<T>

List containing declarations that not have external parent satisfying the provided predicate. The external parent is a parent defined outside the project codebase (defined inside external library).

withoutExternalParentNamed

fun <T : KoExternalParentProvider> List<T>.withoutExternalParentNamed(names: Collection<String>, indirectParents: Boolean = false): List<T>

fun <T : KoExternalParentProvider> List<T>.withoutExternalParentNamed(name: String, vararg names: String, indirectParents: Boolean = false): List<T>

List containing declarations without any of specified external parents. The external parent is a parent defined outside the project codebase (defined inside external library).

withoutExternalParentOf

fun <T : KoExternalParentProvider> List<T>.withoutExternalParentOf(kClasses: Collection<KClass<*>>, indirectParents: Boolean = false): List<T>

fun <T : KoExternalParentProvider> List<T>.withoutExternalParentOf(kClass: KClass<*>, vararg kClasses: KClass<*>, indirectParents: Boolean = false): List<T>

List containing declarations without any external parent of the specified KClass type. The external parent is a parent defined outside the project codebase (defined inside external library).

withoutExternalParents

fun <T : KoExternalParentProvider> List<T>.withoutExternalParents(indirectParents: Boolean = false): List<T>

List containing declarations with none external parent. The external parent is a parent defined outside the project codebase (defined inside external library).

fun <T : KoExternalParentProvider> List<T>.withoutExternalParents(indirectParents: Boolean = false, predicate: (List<KoParentDeclaration>) -> Boolean): List<T>

List containing declarations without external parent declarations satisfying the predicate. The external parent is a parent defined outside the project codebase (defined inside external library).

withoutExternalTypeDeclaration

fun <T : KoDeclarationCastProvider> List<T>.~~withoutExternalTypeDeclaration~~(predicate: (KoExternalDeclaration) -> Boolean? = null): List<T>

List containing declarations without the specified external declaration.

withoutExternalTypeDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.~~withoutExternalTypeDeclarationOf~~(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.~~withoutExternalTypeDeclarationOf~~(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without external declaration of.

withoutFullyQualifiedName

fun <T : KoFullyQualifiedNameProvider> List<T>.withoutFullyQualifiedName(names: Collection<String>): List<T>

fun <T : KoFullyQualifiedNameProvider> List<T>.withoutFullyQualifiedName(name: String, vararg names: String): List<T>

List containing declarations without fully qualified name.

withoutFunction

fun <T : KoFunctionProvider> List<T>.withoutFunction(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (KoFunctionDeclaration) -> Boolean): List<T>

List containing declarations that not have function satisfying the provided predicate.

withoutFunctionNamed

fun <T : KoFunctionProvider> List<T>.withoutFunctionNamed(names: Collection<String>, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

fun <T : KoFunctionProvider> List<T>.withoutFunctionNamed(name: String, vararg names: String, includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations without any of specified functions.

withoutFunctions

fun <T : KoFunctionProvider> List<T>.withoutFunctions(includeNested: Boolean = true, includeLocal: Boolean = true): List<T>

List containing declarations with no functions.

fun <T : KoFunctionProvider> List<T>.withoutFunctions(includeNested: Boolean = true, includeLocal: Boolean = true, predicate: (List<KoFunctionDeclaration>) -> Boolean): List<T>

List containing declarations without function declarations satisfying the predicate.

withoutGeneric

fun <T : KoIsGenericProvider> List<T>.withoutGeneric(): List<T>

List containing declarations that are not generic.

withoutGenericType

fun <T : KoIsGenericTypeProvider> List<T>.~~withoutGenericType~~(): List<T>

List containing declarations without generic type.

withoutGetter

fun <T : KoGetterProvider> List<T>.withoutGetter(): List<T>

List containing declarations without getter.

withoutImport

fun <T : KoImportProvider> List<T>.withoutImport(predicate: (KoImportDeclaration) -> Boolean): List<T>

List containing declarations that not have import satisfying the provided predicate.

withoutImportAlias

fun <T : KoImportAliasProvider> List<T>.withoutImportAlias(predicate: (KoImportAliasDeclaration) -> Boolean): List<T>

List containing declarations that not have import alias satisfying the provided predicate.

withoutImportAliasDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withoutImportAliasDeclaration(predicate: (KoImportAliasDeclaration) -> Boolean? = null): List<T>

List containing declarations without the specified import alias declaration.

withoutImportAliases

fun <T : KoImportAliasProvider> List<T>.withoutImportAliases(): List<T>

List containing declarations with no import alias.

fun <T : KoImportAliasProvider> List<T>.withoutImportAliases(predicate: (List<KoImportAliasDeclaration>) -> Boolean): List<T>

List containing declarations without import alias declarations satisfying the predicate.

withoutImportAliasNamed

fun <T : KoImportAliasProvider> List<T>.withoutImportAliasNamed(names: Collection<String>): List<T>

fun <T : KoImportAliasProvider> List<T>.withoutImportAliasNamed(name: String, vararg names: String): List<T>

List containing declarations without any of specified import aliases.

withoutImportNamed

fun <T : KoImportProvider> List<T>.withoutImportNamed(names: Collection<String>): List<T>

fun <T : KoImportProvider> List<T>.withoutImportNamed(name: String, vararg names: String): List<T>

List containing declarations without any of specified imports.

withoutImports

fun <T : KoImportProvider> List<T>.withoutImports(): List<T>

List containing declarations with no import.

fun <T : KoImportProvider> List<T>.withoutImports(predicate: (List<KoImportDeclaration>) -> Boolean): List<T>

List containing declarations without import declarations satisfying the predicate.

withoutInitBlock

fun <T : KoInitBlockProvider> List<T>.withoutInitBlock(predicate: (KoInitBlockDeclaration) -> Boolean): List<T>

List containing declarations that not have init block satisfying the provided predicate.

withoutInitBlocks

fun <T : KoInitBlockProvider> List<T>.withoutInitBlocks(): List<T>

List containing declarations that don't have init block(s).

fun <T : KoInitBlockProvider> List<T>.withoutInitBlocks(predicate: (List<KoInitBlockDeclaration>) -> Boolean): List<T>

List containing declarations without init block declarations satisfying the predicate.

withoutInitialized

fun <T : KoIsInitializedProvider> List<T>.withoutInitialized(): List<T>

List containing declarations that have not been initialized.

withoutInterface

fun <T : KoInterfaceProvider> List<T>.withoutInterface(includeNested: Boolean = true, predicate: (KoInterfaceDeclaration) -> Boolean): List<T>

List containing declarations that not have interface satisfying the provided predicate.

withoutInterfaceDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withoutInterfaceDeclaration(predicate: (KoInterfaceDeclaration) -> Boolean? = null): List<T>

List containing declarations without the specified interface declaration.

withoutInterfaceDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withoutInterfaceDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withoutInterfaceDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without interface declaration of.

withoutInterfaceNamed

fun <T : KoInterfaceProvider> List<T>.withoutInterfaceNamed(names: Collection<String>, includeNested: Boolean = true): List<T>

fun <T : KoInterfaceProvider> List<T>.withoutInterfaceNamed(name: String, vararg names: String, includeNested: Boolean = true): List<T>

List containing declarations without any of specified interfaces.

withoutInterfaceOrObject

fun <T : KoInterfaceAndObjectProvider> List<T>.withoutInterfaceOrObject(includeNested: Boolean = true, predicate: (KoInterfaceAndObjectDeclaration) -> Boolean): List<T>

List containing declarations that not have interface or object satisfying the provided predicate.

withoutInterfaceOrObjectDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withoutInterfaceOrObjectDeclaration(predicate: (KoInterfaceAndObjectDeclaration) -> Boolean? = null): List<T>

List containing declarations without the specified interface or object declaration.

withoutInterfaceOrObjectDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withoutInterfaceOrObjectDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withoutInterfaceOrObjectDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without interface or object declaration of.

withoutInterfaceOrObjectNamed

fun <T : KoInterfaceAndObjectProvider> List<T>.withoutInterfaceOrObjectNamed(names: Collection<String>, includeNested: Boolean = true): List<T>

fun <T : KoInterfaceAndObjectProvider> List<T>.withoutInterfaceOrObjectNamed(name: String, vararg names: String, includeNested: Boolean = true): List<T>

List containing declarations without any of specified interfaces and objects.

withoutInterfaces

fun <T : KoInterfaceProvider> List<T>.withoutInterfaces(includeNested: Boolean = true): List<T>

List containing declarations with no interfaces.

fun <T : KoInterfaceProvider> List<T>.withoutInterfaces(includeNested: Boolean = true, predicate: (List<KoInterfaceDeclaration>) -> Boolean): List<T>

List containing declarations without interface declarations satisfying the predicate.

withoutInterfacesAndObjects

fun <T : KoInterfaceAndObjectProvider> List<T>.withoutInterfacesAndObjects(includeNested: Boolean = true): List<T>

List containing declarations with no interfaces and objects.

fun <T : KoInterfaceAndObjectProvider> List<T>.withoutInterfacesAndObjects(includeNested: Boolean = true, predicate: (List<KoInterfaceAndObjectDeclaration>) -> Boolean): List<T>

List containing declarations without interfaces and objects declarations satisfying the predicate.

withoutKDoc

fun <T : KoKDocProvider> List<T>.withoutKDoc(): List<T>

List containing declarations without KDoc.

withoutKotlinBasicTypeDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withoutKotlinBasicTypeDeclaration(predicate: (KoKotlinTypeDeclaration) -> Boolean? = null): List<T>

List containing declarations without the specified kotlin basic type declaration.

withoutKotlinBasicTypeDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withoutKotlinBasicTypeDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withoutKotlinBasicTypeDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without kotlin basic type declaration of.

withoutKotlinCollectionTypeDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withoutKotlinCollectionTypeDeclaration(predicate: (KoKotlinTypeDeclaration) -> Boolean? = null): List<T>

List containing declarations without the specified kotlin collection type declaration.

withoutKotlinCollectionTypeDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withoutKotlinCollectionTypeDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withoutKotlinCollectionTypeDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without kotlin collection type declaration of.

withoutKotlinTypeDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withoutKotlinTypeDeclaration(predicate: (KoKotlinTypeDeclaration) -> Boolean? = null): List<T>

List containing declarations without the specified kotlin type declaration.

withoutKotlinTypeDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withoutKotlinTypeDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withoutKotlinTypeDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without kotlin type declaration of.

withoutLocalClass

fun <T : KoLocalClassProvider> List<T>.withoutLocalClass(predicate: (KoClassDeclaration) -> Boolean): List<T>

List containing declarations that not have local class satisfying the provided predicate.

withoutLocalClasses

fun <T : KoLocalClassProvider> List<T>.withoutLocalClasses(): List<T>

List containing declarations with no local classes.

fun <T : KoLocalClassProvider> List<T>.withoutLocalClasses(predicate: (List<KoClassDeclaration>) -> Boolean): List<T>

List containing declarations without local class declarations satisfying the predicate.

withoutLocalClassNamed

fun <T : KoLocalClassProvider> List<T>.withoutLocalClassNamed(names: Collection<String>): List<T>

fun <T : KoLocalClassProvider> List<T>.withoutLocalClassNamed(name: String, vararg names: String): List<T>

List containing declarations without any of specified local classes.

withoutLocalDeclaration

fun <T : KoLocalDeclarationProvider> List<T>.withoutLocalDeclaration(predicate: (KoBaseDeclaration) -> Boolean): List<T>

List containing declarations that not have local declaration satisfying the provided predicate.

withoutLocalDeclarations

fun <T : KoLocalDeclarationProvider> List<T>.withoutLocalDeclarations(): List<T>

List containing declarations with no local declarations.

fun <T : KoLocalDeclarationProvider> List<T>.withoutLocalDeclarations(predicate: (List<KoBaseDeclaration>) -> Boolean): List<T>

List containing declarations without local declarations satisfying the predicate.

withoutLocalFunction

fun <T : KoLocalFunctionProvider> List<T>.withoutLocalFunction(predicate: (KoFunctionDeclaration) -> Boolean): List<T>

List containing declarations that not have local function satisfying the provided predicate.

withoutLocalFunctionNamed

fun <T : KoLocalFunctionProvider> List<T>.withoutLocalFunctionNamed(names: Collection<String>): List<T>

fun <T : KoLocalFunctionProvider> List<T>.withoutLocalFunctionNamed(name: String, vararg names: String): List<T>

List containing declarations without any of specified local functions.

withoutLocalFunctions

fun <T : KoLocalFunctionProvider> List<T>.withoutLocalFunctions(): List<T>

List containing declarations with no local functions.

fun <T : KoLocalFunctionProvider> List<T>.withoutLocalFunctions(predicate: (List<KoFunctionDeclaration>) -> Boolean): List<T>

List containing declarations without local function declarations satisfying the predicate.

withoutMatchingPackage

fun <T : KoHasPackageProvider> List<T>.withoutMatchingPackage(): List<T>

List containing declarations without a matching package.

withoutMatchingPath

fun <T : KoPackageMatchingPathProvider> List<T>.withoutMatchingPath(): List<T>

List containing declarations without a matching path.

withoutModule

fun <T : KoModuleProvider> List<T>.withoutModule(names: Collection<String>): List<T>

fun <T : KoModuleProvider> List<T>.withoutModule(name: String, vararg names: String): List<T>

List containing declarations without module.

withoutMutableType

fun <T : KoIsMutableTypeProvider> List<T>.withoutMutableType(): List<T>

Returns a list of declarations without mutable types.

withoutName

fun <T : KoNameProvider> List<T>.withoutName(vararg names: String): List<T>

fun <T : KoNameProvider> List<T>.withoutName(names: Collection<String>): List<T>

List containing declarations without name.

fun <T : KoNameProvider> List<T>.withoutName(predicate: (String) -> Boolean): List<T>

List containing declarations that don't have a name matching the provided predicate.

withoutNameContaining

fun <T : KoNameProvider> List<T>.withoutNameContaining(texts: Collection<String>): List<T>

fun <T : KoNameProvider> List<T>.withoutNameContaining(text: String, vararg texts: String): List<T>

List containing declarations without name containing any of the specified String.

withoutNameEndingWith

fun <T : KoNameProvider> List<T>.withoutNameEndingWith(suffixes: Collection<String>): List<T>

fun <T : KoNameProvider> List<T>.withoutNameEndingWith(suffix: String, vararg suffixes: String): List<T>

List containing declarations without name with any of the specified suffix.

withoutNameMatching

fun <T : KoNameProvider> List<T>.withoutNameMatching(regexes: Collection<Regex>): List<T>

fun <T : KoNameProvider> List<T>.withoutNameMatching(regex: Regex, vararg regexes: Regex): List<T>

List containing declarations without name matching any of the specified regex.

withoutNameStartingWith

fun <T : KoNameProvider> List<T>.withoutNameStartingWith(prefixes: Collection<String>): List<T>

fun <T : KoNameProvider> List<T>.withoutNameStartingWith(prefix: String, vararg prefixes: String): List<T>

List containing declarations without name with any of the specified prefix.

withoutNullable

fun <T : KoIsNullableProvider> List<T>.withoutNullable(): List<T>

List containing declarations without nullable type.

withoutNullableType

fun <T : KoNullableProvider> List<T>.~~withoutNullableType~~(): List<T>

List containing declarations without nullable type.

withoutObject

fun <T : KoObjectProvider> List<T>.withoutObject(includeNested: Boolean = true, predicate: (KoObjectDeclaration) -> Boolean): List<T>

List containing declarations that not have object satisfying the provided predicate.

withoutObjectDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withoutObjectDeclaration(predicate: (KoObjectDeclaration) -> Boolean? = null): List<T>

List containing declarations without the specified object declaration.

withoutObjectDeclarationOf

fun <T : KoDeclarationCastProvider> List<T>.withoutObjectDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoDeclarationCastProvider> List<T>.withoutObjectDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without object declaration of.

withoutObjectNamed

fun <T : KoObjectProvider> List<T>.withoutObjectNamed(names: Collection<String>, includeNested: Boolean = true): List<T>

fun <T : KoObjectProvider> List<T>.withoutObjectNamed(name: String, vararg names: String, includeNested: Boolean = true): List<T>

List containing declarations without any of specified objects.

withoutObjects

fun <T : KoObjectProvider> List<T>.withoutObjects(includeNested: Boolean = true): List<T>

List containing declarations with no objects.

fun <T : KoObjectProvider> List<T>.withoutObjects(includeNested: Boolean = true, predicate: (List<KoObjectDeclaration>) -> Boolean): List<T>

List containing declarations without object declarations satisfying the predicate.

withoutPackage

fun <T : KoHasPackageProvider> List<T>.withoutPackage(vararg names: String): List<T>

fun <T : KoHasPackageProvider> List<T>.withoutPackage(names: Collection<String>): List<T>

List containing declarations with some package.

fun <T : KoResideInPackageProvider> List<T>.withoutPackage(vararg names: String): List<T>

fun <T : KoResideInPackageProvider> List<T>.withoutPackage(names: Collection<String>): List<T>

List containing elements without package.

withoutParameter

fun <T : KoFunctionTypeDeclarationProvider> List<T>.withoutParameter(predicate: (KoParameterDeclaration) -> Boolean): List<T>

Filters the list by excluding functions that match the parameter predicate.

fun <T : KoParametersProvider> List<T>.withoutParameter(predicate: (KoParameterDeclaration) -> Boolean): List<T>

List containing declarations that not have parameter satisfying the provided predicate.

withoutParameterNamed

fun <T : KoParametersProvider> List<T>.withoutParameterNamed(names: Collection<String>): List<T>

fun <T : KoParametersProvider> List<T>.withoutParameterNamed(name: String, vararg names: String): List<T>

List containing declarations without any of specified parameters.

withoutParameters

fun <T : KoParametersProvider> List<T>.withoutParameters(): List<T>

List containing declarations with no parameters.

fun <T : KoFunctionTypeDeclarationProvider> List<T>.withoutParameters(predicate: (List<KoParameterDeclaration>) -> Boolean): List<T>

Filters the list by excluding functions that match the parameters predicate as a collection.

fun <T : KoParametersProvider> List<T>.withoutParameters(predicate: (List<KoParameterDeclaration>) -> Boolean): List<T>

List containing declarations without parameter declarations satisfying the predicate.

withoutParameterType

fun <T : KoFunctionTypeDeclarationProvider> List<T>.~~withoutParameterType~~(predicate: (KoParameterDeclaration) -> Boolean): List<T>

Filters the list by excluding functions that match the parameter type predicate.

withoutParameterTypes

fun <T : KoFunctionTypeDeclarationProvider> List<T>.~~withoutParameterTypes~~(predicate: (List<KoParameterDeclaration>) -> Boolean): List<T>

Filters the list by excluding functions that match the parameter types predicate as a collection.

withoutParent

fun <T : KoParentProvider> List<T>.withoutParent(indirectParents: Boolean = false, predicate: (KoParentDeclaration) -> Boolean): List<T>

List containing declarations that not have parent satisfying the provided predicate.

withoutParentClass

fun <T : KoParentClassProvider> List<T>.withoutParentClass(): List<T>

List containing declarations without direct parent class.

fun <T : KoParentClassProvider> List<T>.withoutParentClass(indirectParents: Boolean = false, predicate: (KoParentDeclaration) -> Boolean): List<T>

List containing declarations without the specified parent class.

withoutParentClasses

fun <T : KoParentClassProvider> List<T>.withoutParentClasses(indirectParents: Boolean = false): List<T>

List containing declarations with none parent class.

fun <T : KoParentClassProvider> List<T>.withoutParentClasses(indirectParents: Boolean = false, predicate: (List<KoParentDeclaration>) -> Boolean): List<T>

List containing declarations without parent class declarations satisfying the predicate.

withoutParentClassNamed

fun <T : KoParentClassProvider> List<T>.withoutParentClassNamed(names: Collection<String>, indirectParents: Boolean = false): List<T>

fun <T : KoParentClassProvider> List<T>.withoutParentClassNamed(name: String, vararg names: String, indirectParents: Boolean = false): List<T>

List containing declarations without any of specified parent classes.

withoutParentClassOf

fun <T : KoParentClassProvider> List<T>.withoutParentClassOf(kClasses: Collection<KClass<*>>, indirectParents: Boolean = false): List<T>

fun <T : KoParentClassProvider> List<T>.withoutParentClassOf(kClass: KClass<*>, vararg kClasses: KClass<*>, indirectParents: Boolean = false): List<T>

List containing declarations without parent class.

withoutParentInterface

fun <T : KoParentInterfaceProvider> List<T>.withoutParentInterface(indirectParents: Boolean = false, predicate: (KoParentDeclaration) -> Boolean): List<T>

List containing declarations that not have parent interface satisfying the provided predicate.

withoutParentInterfaceNamed

fun <T : KoParentInterfaceProvider> List<T>.withoutParentInterfaceNamed(names: Collection<String>, indirectParents: Boolean = false): List<T>

fun <T : KoParentInterfaceProvider> List<T>.withoutParentInterfaceNamed(name: String, vararg names: String, indirectParents: Boolean = false): List<T>

List containing declarations without any of specified parent interfaces.

withoutParentInterfaceOf

fun <T : KoParentInterfaceProvider> List<T>.withoutParentInterfaceOf(kClasses: Collection<KClass<*>>, indirectParents: Boolean = false): List<T>

fun <T : KoParentInterfaceProvider> List<T>.withoutParentInterfaceOf(kClass: KClass<*>, vararg kClasses: KClass<*>, indirectParents: Boolean = false): List<T>

List containing declarations without any parent interface of the specified KClass type.

withoutParentInterfaces

fun <T : KoParentInterfaceProvider> List<T>.withoutParentInterfaces(indirectParents: Boolean = false): List<T>

List containing declarations with none parent interface.

fun <T : KoParentInterfaceProvider> List<T>.withoutParentInterfaces(indirectParents: Boolean = false, predicate: (List<KoParentDeclaration>) -> Boolean): List<T>

List containing declarations without parent interface declarations satisfying the predicate.

withoutParentNamed

fun <T : KoParentProvider> List<T>.withoutParentNamed(names: Collection<String>, indirectParents: Boolean = false): List<T>

fun <T : KoParentProvider> List<T>.withoutParentNamed(name: String, vararg names: String, indirectParents: Boolean = false): List<T>

List containing declarations without any of specified parents.

withoutParentOf

fun <T : KoParentProvider> List<T>.withoutParentOf(kClasses: Collection<KClass<*>>, indirectParents: Boolean = false): List<T>

fun <T : KoParentProvider> List<T>.withoutParentOf(kClass: KClass<*>, vararg kClasses: KClass<*>, indirectParents: Boolean = false): List<T>

List containing declarations without any parent of the specified KClass type.

withoutParents

fun <T : KoParentProvider> List<T>.withoutParents(indirectParents: Boolean = false): List<T>

List containing declarations with none parent - declaration does not extend any class and does not implement any interface.

fun <T : KoParentProvider> List<T>.withoutParents(indirectParents: Boolean = false, predicate: (List<KoParentDeclaration>) -> Boolean): List<T>

List containing declarations without parent declarations satisfying the predicate.

withoutPath

fun <T : KoPathProvider> List<T>.withoutPath(paths: Collection<String>, absolutePath: Boolean = false): List<T>

fun <T : KoPathProvider> List<T>.withoutPath(path: String, vararg paths: String, absolutePath: Boolean = false): List<T>

List containing declarations without path.

withoutPrimaryConstructor

fun <T : KoPrimaryConstructorProvider> List<T>.withoutPrimaryConstructor(): List<T>

List containing declarations that don't have primary constructor.

withoutProjectPath

fun <T : KoPathProvider> List<T>.withoutProjectPath(paths: Collection<String>): List<T>

fun <T : KoPathProvider> List<T>.withoutProjectPath(paths: List<String>): List<T>

fun <T : KoPathProvider> List<T>.withoutProjectPath(path: String, vararg paths: String): List<T>

List containing declarations without project path.

withoutProperties

fun <T : KoPropertyProvider> List<T>.withoutProperties(includeNested: Boolean = true): List<T>

List containing declarations with no properties.

fun <T : KoPropertyProvider> List<T>.withoutProperties(includeNested: Boolean = true, predicate: (List<KoPropertyDeclaration>) -> Boolean): List<T>

List containing declarations without property declarations satisfying the predicate.

withoutProperty

fun <T : KoPropertyProvider> List<T>.withoutProperty(includeNested: Boolean = true, predicate: (KoPropertyDeclaration) -> Boolean): List<T>

List containing declarations that not have property satisfying the provided predicate.

withoutPropertyNamed

fun <T : KoPropertyProvider> List<T>.withoutPropertyNamed(names: Collection<String>, includeNested: Boolean = true): List<T>

fun <T : KoPropertyProvider> List<T>.withoutPropertyNamed(name: String, vararg names: String, includeNested: Boolean = true): List<T>

List containing declarations without any of specified properties.

withoutReadOnly

fun <T : KoIsReadOnlyProvider> List<T>.withoutReadOnly(): List<T>

List containing declarations that are not read only.

withoutReceiverType

fun <T : KoReceiverTypeProvider> List<T>.withoutReceiverType(predicate: (KoTypeDeclaration) -> Boolean? = null): List<T>

List containing declarations without the specified receiver type.

withoutReceiverTypeOf

fun <T : KoReceiverTypeProvider> List<T>.withoutReceiverTypeOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoReceiverTypeProvider> List<T>.withoutReceiverTypeOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without receiver type.

withoutRepresentedType

fun <T : KoRepresentsTypeProvider> List<T>.withoutRepresentedType(names: Collection<String?>): List<T>

fun <T : KoRepresentsTypeProvider> List<T>.withoutRepresentedType(name: String?, vararg names: String?): List<T>

List containing declarations that do not represent the type.

withoutRepresentedTypeOf

fun <T : KoRepresentsTypeProvider> List<T>.withoutRepresentedTypeOf(kClasses: Collection<KClass<*>?>): List<T>

fun <T : KoRepresentsTypeProvider> List<T>.withoutRepresentedTypeOf(kClass: KClass<*>?, vararg kClasses: KClass<*>?): List<T>

List containing declarations that do not represent the type.

withoutReturnType

fun <T : KoFunctionTypeDeclarationProvider> List<T>.withoutReturnType(predicate: (KoTypeDeclaration) -> Boolean): List<T>

Filters the list by excluding function declarations that match the return type predicate.

fun <T : KoReturnProvider> List<T>.withoutReturnType(predicate: (KoTypeDeclaration) -> Boolean? = null): List<T>

List containing declarations without the specified return type.

withoutReturnTypeOf

fun <T : KoFunctionTypeDeclarationProvider> List<T>.withoutReturnTypeOf(kClasses: Collection<KClass<*>>): List<T>

Filters the list to exclude functions that return a type of the specified classes.

fun <T : KoReturnProvider> List<T>.withoutReturnTypeOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoReturnProvider> List<T>.withoutReturnTypeOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without return type.

fun <T : KoFunctionTypeDeclarationProvider> List<T>.withoutReturnTypeOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

Filters the list to exclude functions that return a type of the specified class(es).

withoutReturnValue

fun <T : KoReturnProvider> List<T>.withoutReturnValue(): List<T>

List containing declarations with the Unit return value, which may or may not have explicitly defined return types.

withoutSecondaryConstructor

fun <T : KoSecondaryConstructorsProvider> List<T>.withoutSecondaryConstructor(predicate: (KoSecondaryConstructorDeclaration) -> Boolean): List<T>

List containing declarations that not have secondary constructor satisfying the provided predicate.

withoutSecondaryConstructors

fun <T : KoSecondaryConstructorsProvider> List<T>.withoutSecondaryConstructors(): List<T>

List containing declarations that don't have secondary constructors.

fun <T : KoSecondaryConstructorsProvider> List<T>.withoutSecondaryConstructors(predicate: (List<KoSecondaryConstructorDeclaration>) -> Boolean): List<T>

List containing declarations without secondary constructor declarations satisfying the predicate.

withoutSetter

fun <T : KoSetterProvider> List<T>.withoutSetter(): List<T>

List containing declarations without setter.

withoutSourceDeclaration

fun <T : KoSourceDeclarationProvider> List<T>.withoutSourceDeclaration(predicate: (KoDeclarationCastProvider) -> Boolean): List<T>

List containing source declarations without the specified source declaration.

withoutSourceDeclarationOf

fun <T : KoSourceDeclarationProvider> List<T>.withoutSourceDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoSourceDeclarationProvider> List<T>.withoutSourceDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without source declaration of.

withoutSourceSet

fun <T : KoSourceSetProvider> List<T>.withoutSourceSet(names: Collection<String>): List<T>

fun <T : KoSourceSetProvider> List<T>.withoutSourceSet(name: String, vararg names: String): List<T>

List containing declarations without source set.

withoutSourceType

fun <T : KoSourceTypeProvider> List<T>.withoutSourceType(names: Collection<String>): List<T>

fun <T : KoSourceTypeProvider> List<T>.withoutSourceType(name: String, vararg names: String): List<T>

List containing declarations without source type.

withoutSourceTypeOf

fun <T : KoSourceTypeProvider> List<T>.withoutSourceTypeOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoSourceTypeProvider> List<T>.withoutSourceTypeOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without source type of.

withoutStarProjection

fun <T : KoIsStarProjectionProvider> List<T>.withoutStarProjection(): List<T>

List containing the star projection declarations.

withoutTacitType

fun <T : KoTacitTypeProvider> List<T>.withoutTacitType(types: Collection<String>): List<T>

fun <T : KoTacitTypeProvider> List<T>.withoutTacitType(type: String, vararg types: String): List<T>

List containing declarations without tacit type.

withoutTacitTypeOf

fun <T : KoTacitTypeProvider> List<T>.withoutTacitTypeOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoTacitTypeProvider> List<T>.withoutTacitTypeOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without tacit type.

withoutTestClass

fun <T : KoTestClassProvider> List<T>.withoutTestClass(testPropertyName: String = "sut", moduleName: String? = null, sourceSetName: String? = null): List<T>

List containing declarations without a test.

fun <T : KoTestClassProvider> List<T>.withoutTestClass(moduleName: String? = null, sourceSetName: String? = null, predicate: (KoClassDeclaration) -> Boolean): List<T>

List containing declarations without a test matching the predicate.

withoutText

fun <T : KoTextProvider> List<T>.withoutText(vararg texts: String): List<T>

fun <T : KoTextProvider> List<T>.withoutText(texts: Collection<String>): List<T>

List containing declarations without text.

fun <T : KoTextProvider> List<T>.withoutText(predicate: (String) -> Boolean): List<T>

List containing declarations that don't have a text matching the provided predicate.

withoutTextContaining

fun <T : KoTextProvider> List<T>.withoutTextContaining(texts: Collection<String>): List<T>

fun <T : KoTextProvider> List<T>.withoutTextContaining(text: String, vararg texts: String): List<T>

List containing declarations without text containing any of the specified String.

withoutTextEndingWith

fun <T : KoTextProvider> List<T>.withoutTextEndingWith(suffixes: Collection<String>): List<T>

fun <T : KoTextProvider> List<T>.withoutTextEndingWith(suffix: String, vararg suffixes: String): List<T>

List containing declarations without text with any of the specified suffix.

withoutTextMatching

fun <T : KoTextProvider> List<T>.withoutTextMatching(regexes: Collection<Regex>): List<T>

fun <T : KoTextProvider> List<T>.withoutTextMatching(regex: Regex, vararg regexes: Regex): List<T>

List containing declarations without text matching any of the specified regex.

withoutTextStartingWith

fun <T : KoTextProvider> List<T>.withoutTextStartingWith(prefixes: Collection<String>): List<T>

fun <T : KoTextProvider> List<T>.withoutTextStartingWith(prefix: String, vararg prefixes: String): List<T>

List containing declarations without text with any of the specified prefix.

withoutTopLevel

fun <T : KoIsTopLevelProvider> List<T>.withoutTopLevel(): List<T>

List containing the non-top level declarations.

withoutType

fun <T : KoNonNullableTypeProvider> List<T>.withoutType(predicate: (KoTypeDeclaration) -> Boolean): List<T>

fun <T : KoNullableTypeProvider> List<T>.withoutType(predicate: (KoTypeDeclaration) -> Boolean? = null): List<T>

List containing declarations without the specified type.

withoutTypeAlias

fun <T : KoTypeAliasProvider> List<T>.withoutTypeAlias(predicate: (KoTypeAliasDeclaration) -> Boolean): List<T>

List containing declarations that not have type alias satisfying the provided predicate.

withoutTypeAliasDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withoutTypeAliasDeclaration(predicate: (KoTypeAliasDeclaration) -> Boolean? = null): List<T>

List containing declarations without the specified type alias declaration.

withoutTypeAliases

fun <T : KoTypeAliasProvider> List<T>.withoutTypeAliases(): List<T>

List containing declarations with no type aliases.

fun <T : KoTypeAliasProvider> List<T>.withoutTypeAliases(predicate: (List<KoTypeAliasDeclaration>) -> Boolean): List<T>

List containing declarations without type alias declarations satisfying the predicate.

withoutTypeAliasNamed

fun <T : KoTypeAliasProvider> List<T>.withoutTypeAliasNamed(names: Collection<String>): List<T>

fun <T : KoTypeAliasProvider> List<T>.withoutTypeAliasNamed(name: String, vararg names: String): List<T>

List containing declarations without any of specified type aliases.

withoutTypeArgument

fun <T : KoTypeArgumentProvider> List<T>.withoutTypeArgument(predicate: (KoTypeArgumentDeclaration) -> Boolean): List<T>

List containing declarations that not have type argument satisfying the provided predicate.

withoutTypeArgumentNamed

fun <T : KoTypeArgumentProvider> List<T>.withoutTypeArgumentNamed(names: Collection<String>): List<T>

fun <T : KoTypeArgumentProvider> List<T>.withoutTypeArgumentNamed(name: String, vararg names: String): List<T>

List containing declarations without any of specified type arguments.

withoutTypeArguments

fun <T : KoTypeArgumentProvider> List<T>.withoutTypeArguments(): List<T>

List containing declarations with no type arguments.

fun <T : KoTypeArgumentProvider> List<T>.withoutTypeArguments(predicate: (List<KoTypeArgumentDeclaration>) -> Boolean): List<T>

List containing declarations without type argument declarations satisfying the predicate.

withoutTypeOf

fun <T : KoNonNullableTypeProvider> List<T>.withoutTypeOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoNullableTypeProvider> List<T>.withoutTypeOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoNonNullableTypeProvider> List<T>.withoutTypeOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

fun <T : KoNullableTypeProvider> List<T>.withoutTypeOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations without type of.

withoutTypeParameter

fun <T : KoTypeParameterProvider> List<T>.withoutTypeParameter(predicate: (KoTypeParameterDeclaration) -> Boolean): List<T>

List containing declarations that not have type parameter satisfying the provided predicate.

withoutTypeParameterDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withoutTypeParameterDeclaration(predicate: (KoTypeParameterDeclaration) -> Boolean? = null): List<T>

List containing declarations without the specified type parameter declaration.

withoutTypeParameterNamed

fun <T : KoTypeParameterProvider> List<T>.withoutTypeParameterNamed(names: Collection<String>): List<T>

fun <T : KoTypeParameterProvider> List<T>.withoutTypeParameterNamed(name: String, vararg names: String): List<T>

List containing declarations without any of specified type parameters.

withoutTypeParameters

fun <T : KoTypeParameterProvider> List<T>.withoutTypeParameters(): List<T>

List containing declarations with no type parameters.

fun <T : KoTypeParameterProvider> List<T>.withoutTypeParameters(predicate: (List<KoTypeParameterDeclaration>) -> Boolean): List<T>

List containing declarations without type parameter declarations satisfying the predicate.

withoutUpperBound

fun <T : KoUpperBoundsProvider> List<T>.withoutUpperBound(predicate: (KoTypeDeclaration) -> Boolean): List<T>

List containing declarations that not have upper bound satisfying the provided predicate.

withoutUpperBoundNamed

fun <T : KoUpperBoundsProvider> List<T>.withoutUpperBoundNamed(names: Collection<String>): List<T>

fun <T : KoUpperBoundsProvider> List<T>.withoutUpperBoundNamed(name: String, vararg names: String): List<T>

List containing declarations without any of specified upper bounds.

withoutUpperBounds

fun <T : KoUpperBoundsProvider> List<T>.withoutUpperBounds(): List<T>

List containing declarations with no upper bounds.

fun <T : KoUpperBoundsProvider> List<T>.withoutUpperBounds(predicate: (List<KoTypeDeclaration>) -> Boolean): List<T>

List containing declarations without upper bound declarations satisfying the predicate.

withoutVal

fun <T : KoIsValProvider> List<T>.withoutVal(): List<T>

List containing declarations without val keyword.

withoutValue

fun <T : KoValueProvider> List<T>.withoutValue(vararg values: String): List<T>

fun <T : KoValueProvider> List<T>.withoutValue(values: Collection<String>): List<T>

List containing elements without value.

fun <T : KoValueProvider> List<T>.withoutValue(predicate: (String) -> Boolean): List<T>

List containing declarations that don't have a value matching the provided predicate.

withoutVar

fun <T : KoIsVarProvider> List<T>.withoutVar(): List<T>

List containing declarations without var keyword.

withoutVariable

fun <T : KoVariableProvider> List<T>.withoutVariable(predicate: (KoVariableDeclaration) -> Boolean): List<T>

List containing declarations that not have variable satisfying the provided predicate.

withoutVariableNamed

fun <T : KoVariableProvider> List<T>.withoutVariableNamed(names: Collection<String>): List<T>

fun <T : KoVariableProvider> List<T>.withoutVariableNamed(name: String, vararg names: String): List<T>

List containing declarations without any of specified variables.

withoutVariables

fun <T : KoVariableProvider> List<T>.withoutVariables(): List<T>

List containing declarations with no variables.

fun <T : KoVariableProvider> List<T>.withoutVariables(predicate: (List<KoVariableDeclaration>) -> Boolean): List<T>

List containing declarations without variable declarations satisfying the predicate.

withoutWildcard

fun <T : KoIsWildcardProvider> List<T>.withoutWildcard(): List<T>

List containing declarations without a wildcard.

withPackage

fun <T : KoHasPackageProvider> List<T>.withPackage(vararg names: String): List<T>

fun <T : KoHasPackageProvider> List<T>.withPackage(names: Collection<String>): List<T>

List containing declarations with package.

fun <T : KoResideInPackageProvider> List<T>.withPackage(vararg names: String): List<T>

fun <T : KoResideInPackageProvider> List<T>.withPackage(names: Collection<String>): List<T>

List containing elements with package.

withParameter

fun <T : KoFunctionTypeDeclarationProvider> List<T>.withParameter(predicate: (KoParameterDeclaration) -> Boolean): List<T>

Filters the list by parameter using the given predicate.

fun <T : KoParametersProvider> List<T>.withParameter(predicate: (KoParameterDeclaration) -> Boolean): List<T>

List containing declarations that have at least one parameter satisfying the provided predicate.

withParameterNamed

fun <T : KoParametersProvider> List<T>.withParameterNamed(names: Collection<String>): List<T>

fun <T : KoParametersProvider> List<T>.withParameterNamed(name: String, vararg names: String): List<T>

List containing declarations that have at least one parameter with the specified name(s).

withParameters

fun <T : KoParametersProvider> List<T>.withParameters(): List<T>

List containing declarations with any parameter.

fun <T : KoFunctionTypeDeclarationProvider> List<T>.withParameters(predicate: (List<KoParameterDeclaration>) -> Boolean): List<T>

Filters the list by parameters as a collection using the given predicate.

fun <T : KoParametersProvider> List<T>.withParameters(predicate: (List<KoParameterDeclaration>) -> Boolean): List<T>

List containing declarations with parameter declarations satisfying the predicate.

withParameterType

fun <T : KoFunctionTypeDeclarationProvider> List<T>.~~withParameterType~~(predicate: (KoParameterDeclaration) -> Boolean): List<T>

Filters the list by parameter type using the given predicate.

withParameterTypes

fun <T : KoFunctionTypeDeclarationProvider> List<T>.~~withParameterTypes~~(predicate: (List<KoParameterDeclaration>) -> Boolean): List<T>

Filters the list by parameter types as a collection using the given predicate.

withParent

fun <T : KoParentProvider> List<T>.withParent(indirectParents: Boolean = false, predicate: (KoParentDeclaration) -> Boolean): List<T>

List containing declarations that have at least one parent satisfying the provided predicate.

withParentClass

fun <T : KoParentClassProvider> List<T>.withParentClass(): List<T>

List containing declarations with any direct parent class.

fun <T : KoParentClassProvider> List<T>.withParentClass(indirectParents: Boolean = false, predicate: (KoParentDeclaration) -> Boolean): List<T>

List containing declarations with the specified parent class.

withParentClasses

fun <T : KoParentClassProvider> List<T>.withParentClasses(indirectParents: Boolean = false): List<T>

List containing declarations with any parent class.

fun <T : KoParentClassProvider> List<T>.withParentClasses(indirectParents: Boolean = false, predicate: (List<KoParentDeclaration>) -> Boolean): List<T>

List containing declarations with parent class declarations satisfying the predicate.

withParentClassNamed

fun <T : KoParentClassProvider> List<T>.withParentClassNamed(names: Collection<String>, indirectParents: Boolean = false): List<T>

fun <T : KoParentClassProvider> List<T>.withParentClassNamed(name: String, vararg names: String, indirectParents: Boolean = false): List<T>

List containing declarations that have parent class with the specified name(s).

withParentClassOf

fun <T : KoParentClassProvider> List<T>.withParentClassOf(kClasses: Collection<KClass<*>>, indirectParents: Boolean = false): List<T>

fun <T : KoParentClassProvider> List<T>.withParentClassOf(kClass: KClass<*>, vararg kClasses: KClass<*>, indirectParents: Boolean = false): List<T>

List containing declarations that have parent class of type.

withParentInterface

fun <T : KoParentInterfaceProvider> List<T>.withParentInterface(indirectParents: Boolean = false, predicate: (KoParentDeclaration) -> Boolean): List<T>

List containing declarations that have at least one parent interface satisfying the provided predicate.

withParentInterfaceNamed

fun <T : KoParentInterfaceProvider> List<T>.withParentInterfaceNamed(names: Collection<String>, indirectParents: Boolean = false): List<T>

fun <T : KoParentInterfaceProvider> List<T>.withParentInterfaceNamed(name: String, vararg names: String, indirectParents: Boolean = false): List<T>

List containing declarations that have at least one parent interface with the specified name(s).

withParentInterfaceOf

fun <T : KoParentInterfaceProvider> List<T>.withParentInterfaceOf(kClasses: Collection<KClass<*>>, indirectParents: Boolean = false): List<T>

fun <T : KoParentInterfaceProvider> List<T>.withParentInterfaceOf(kClass: KClass<*>, vararg kClasses: KClass<*>, indirectParents: Boolean = false): List<T>

List containing declarations that have at least one parent interface of the specified KClass type.

withParentInterfaces

fun <T : KoParentInterfaceProvider> List<T>.withParentInterfaces(indirectParents: Boolean = false): List<T>

List containing declarations with any parent interface.

fun <T : KoParentInterfaceProvider> List<T>.withParentInterfaces(indirectParents: Boolean = false, predicate: (List<KoParentDeclaration>) -> Boolean): List<T>

List containing declarations with parent interface declarations satisfying the predicate.

withParentNamed

fun <T : KoParentProvider> List<T>.withParentNamed(names: Collection<String>, indirectParents: Boolean = false): List<T>

fun <T : KoParentProvider> List<T>.withParentNamed(name: String, vararg names: String, indirectParents: Boolean = false): List<T>

List containing declarations that have at least one parent with the specified name(s).

withParentOf

fun <T : KoParentProvider> List<T>.withParentOf(kClasses: Collection<KClass<*>>, indirectParents: Boolean = false): List<T>

fun <T : KoParentProvider> List<T>.withParentOf(kClass: KClass<*>, vararg kClasses: KClass<*>, indirectParents: Boolean = false): List<T>

List containing declarations that have at least one parent of the specified KClass type.

withParents

fun <T : KoParentProvider> List<T>.withParents(indirectParents: Boolean = false): List<T>

List containing declarations with any parent.

fun <T : KoParentProvider> List<T>.withParents(indirectParents: Boolean = false, predicate: (List<KoParentDeclaration>) -> Boolean): List<T>

List containing declarations with parent declarations satisfying the predicate.

withPath

fun <T : KoPathProvider> List<T>.withPath(paths: Collection<String>, absolutePath: Boolean = false): List<T>

fun <T : KoPathProvider> List<T>.withPath(path: String, vararg paths: String, absolutePath: Boolean = false): List<T>

List containing declarations with path.

withPrimaryConstructor

fun <T : KoPrimaryConstructorProvider> List<T>.withPrimaryConstructor(): List<T>

List containing declarations that have primary constructor.

withProjectPath

fun <T : KoPathProvider> List<T>.withProjectPath(paths: Collection<String>): List<T>

fun <T : KoPathProvider> List<T>.withProjectPath(paths: List<String>): List<T>

fun <T : KoPathProvider> List<T>.withProjectPath(path: String, vararg paths: String): List<T>

List containing declarations with project path.

withProperties

fun <T : KoPropertyProvider> List<T>.withProperties(includeNested: Boolean = true): List<T>

List containing declarations with any property.

fun <T : KoPropertyProvider> List<T>.withProperties(includeNested: Boolean = true, predicate: (List<KoPropertyDeclaration>) -> Boolean): List<T>

List containing declarations with property declarations satisfying the predicate.

withProperty

fun <T : KoPropertyProvider> List<T>.withProperty(includeNested: Boolean = true, predicate: (KoPropertyDeclaration) -> Boolean): List<T>

List containing declarations that have at least one property satisfying the provided predicate.

withPropertyNamed

fun <T : KoPropertyProvider> List<T>.withPropertyNamed(names: Collection<String>, includeNested: Boolean = true): List<T>

fun <T : KoPropertyProvider> List<T>.withPropertyNamed(name: String, vararg names: String, includeNested: Boolean = true): List<T>

List containing declarations that have at least one property with the specified name(s).

withReadOnly

fun <T : KoIsReadOnlyProvider> List<T>.withReadOnly(): List<T>

List containing declarations that are read only.

withReceiverType

fun <T : KoReceiverTypeProvider> List<T>.withReceiverType(predicate: (KoTypeDeclaration) -> Boolean? = null): List<T>

List containing declarations with the specified receiver type.

withReceiverTypeOf

fun <T : KoReceiverTypeProvider> List<T>.withReceiverTypeOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoReceiverTypeProvider> List<T>.withReceiverTypeOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations with receiver type.

withRepresentedType

fun <T : KoRepresentsTypeProvider> List<T>.withRepresentedType(names: Collection<String?>): List<T>

fun <T : KoRepresentsTypeProvider> List<T>.withRepresentedType(name: String?, vararg names: String?): List<T>

List containing declarations that represents the type.

withRepresentedTypeOf

fun <T : KoRepresentsTypeProvider> List<T>.withRepresentedTypeOf(kClasses: Collection<KClass<*>?>): List<T>

fun <T : KoRepresentsTypeProvider> List<T>.withRepresentedTypeOf(kClass: KClass<*>?, vararg kClasses: KClass<*>?): List<T>

List containing declarations that represents the type.

withReturnType

fun <T : KoFunctionTypeDeclarationProvider> List<T>.withReturnType(predicate: (KoTypeDeclaration) -> Boolean): List<T>

Filters the list by return type using the given predicate.

fun <T : KoReturnProvider> List<T>.withReturnType(predicate: (KoTypeDeclaration) -> Boolean? = null): List<T>

List containing declarations with the specified return type.

withReturnTypeOf

fun <T : KoFunctionTypeDeclarationProvider> List<T>.withReturnTypeOf(kClasses: Collection<KClass<*>>): List<T>

Filters the list to include only the functions that return a type of the specified classes.

fun <T : KoReturnProvider> List<T>.withReturnTypeOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoReturnProvider> List<T>.withReturnTypeOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations with return type.

fun <T : KoFunctionTypeDeclarationProvider> List<T>.withReturnTypeOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

Filters the list to include only the functions that return a type of the specified class(es).

withReturnValue

fun <T : KoReturnProvider> List<T>.withReturnValue(): List<T>

List containing declarations with non-Unit return values, which may or may not have explicitly defined return types.

withSecondaryConstructor

fun <T : KoSecondaryConstructorsProvider> List<T>.withSecondaryConstructor(predicate: (KoSecondaryConstructorDeclaration) -> Boolean): List<T>

List containing declarations that have at least one secondary constructor satisfying the provided predicate.

withSecondaryConstructors

fun <T : KoSecondaryConstructorsProvider> List<T>.withSecondaryConstructors(): List<T>

List containing declarations that have secondary constructors.

fun <T : KoSecondaryConstructorsProvider> List<T>.withSecondaryConstructors(predicate: (List<KoSecondaryConstructorDeclaration>) -> Boolean): List<T>

List containing declarations with secondary constructor declarations satisfying the predicate.

withSetter

fun <T : KoSetterProvider> List<T>.withSetter(): List<T>

List containing declarations with setter.

withSourceDeclaration

fun <T : KoSourceDeclarationProvider> List<T>.withSourceDeclaration(predicate: (KoDeclarationCastProvider) -> Boolean): List<T>

List containing source declarations with the specified source declaration.

withSourceDeclarationOf

fun <T : KoSourceDeclarationProvider> List<T>.withSourceDeclarationOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoSourceDeclarationProvider> List<T>.withSourceDeclarationOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations with source declaration of.

withSourceSet

fun <T : KoSourceSetProvider> List<T>.withSourceSet(names: Collection<String>): List<T>

fun <T : KoSourceSetProvider> List<T>.withSourceSet(name: String, vararg names: String): List<T>

List containing declarations with source set.

withSourceType

fun <T : KoSourceTypeProvider> List<T>.withSourceType(names: Collection<String>): List<T>

fun <T : KoSourceTypeProvider> List<T>.withSourceType(name: String, vararg names: String): List<T>

List containing declarations with source type.

withSourceTypeOf

fun <T : KoSourceTypeProvider> List<T>.withSourceTypeOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoSourceTypeProvider> List<T>.withSourceTypeOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations with source type of.

withStarProjection

fun <T : KoIsStarProjectionProvider> List<T>.withStarProjection(): List<T>

List containing the star projection declarations.

withTacitType

fun <T : KoTacitTypeProvider> List<T>.withTacitType(types: Collection<String>): List<T>

fun <T : KoTacitTypeProvider> List<T>.withTacitType(type: String, vararg types: String): List<T>

List containing declarations with tacit type.

withTacitTypeOf

fun <T : KoTacitTypeProvider> List<T>.withTacitTypeOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoTacitTypeProvider> List<T>.withTacitTypeOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations with tacit type.

withTestClass

fun <T : KoTestClassProvider> List<T>.withTestClass(testPropertyName: String = "sut", moduleName: String? = null, sourceSetName: String? = null): List<T>

List containing declarations with a test.

fun <T : KoTestClassProvider> List<T>.withTestClass(moduleName: String? = null, sourceSetName: String? = null, predicate: (KoClassDeclaration) -> Boolean): List<T>

List containing declarations with a test matching the predicate.

withText

fun <T : KoTextProvider> List<T>.withText(vararg texts: String): List<T>

fun <T : KoTextProvider> List<T>.withText(texts: Collection<String>): List<T>

List containing declarations with text.

fun <T : KoTextProvider> List<T>.withText(predicate: (String) -> Boolean): List<T>

List containing declarations that have a text matching the provided predicate.

withTextContaining

fun <T : KoTextProvider> List<T>.withTextContaining(texts: Collection<String>): List<T>

fun <T : KoTextProvider> List<T>.withTextContaining(text: String, vararg texts: String): List<T>

List containing declarations with text containing any of the specified String.

withTextEndingWith

fun <T : KoTextProvider> List<T>.withTextEndingWith(suffixes: Collection<String>): List<T>

fun <T : KoTextProvider> List<T>.withTextEndingWith(suffix: String, vararg suffixes: String): List<T>

List containing declarations with text with any of the specified suffix.

withTextMatching

fun <T : KoTextProvider> List<T>.withTextMatching(regexes: Collection<Regex>): List<T>

fun <T : KoTextProvider> List<T>.withTextMatching(regex: Regex, vararg regexes: Regex): List<T>

List containing declarations with text matching any of the specified regex.

withTextStartingWith

fun <T : KoTextProvider> List<T>.withTextStartingWith(prefixes: Collection<String>): List<T>

fun <T : KoTextProvider> List<T>.withTextStartingWith(prefix: String, vararg prefixes: String): List<T>

List containing declarations with text with any of the specified prefix.

withTopLevel

fun <T : KoIsTopLevelProvider> List<T>.withTopLevel(): List<T>

List containing the top level declarations.

withType

fun <T : KoNonNullableTypeProvider> List<T>.withType(predicate: (KoTypeDeclaration) -> Boolean): List<T>

fun <T : KoNullableTypeProvider> List<T>.withType(predicate: (KoTypeDeclaration) -> Boolean? = null): List<T>

List containing declarations with the specified type.

withTypeAlias

fun <T : KoTypeAliasProvider> List<T>.withTypeAlias(predicate: (KoTypeAliasDeclaration) -> Boolean): List<T>

List containing declarations that have at least one type alias satisfying the provided predicate.

withTypeAliasDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withTypeAliasDeclaration(predicate: (KoTypeAliasDeclaration) -> Boolean? = null): List<T>

List containing declarations with the specified type alias declaration.

withTypeAliases

fun <T : KoTypeAliasProvider> List<T>.withTypeAliases(): List<T>

List containing declarations with any type alias.

fun <T : KoTypeAliasProvider> List<T>.withTypeAliases(predicate: (List<KoTypeAliasDeclaration>) -> Boolean): List<T>

List containing declarations with type alias declarations satisfying the predicate.

withTypeAliasNamed

fun <T : KoTypeAliasProvider> List<T>.withTypeAliasNamed(names: Collection<String>): List<T>

fun <T : KoTypeAliasProvider> List<T>.withTypeAliasNamed(name: String, vararg names: String): List<T>

List containing declarations that have at least one type alias with the specified name(s).

withTypeArgument

fun <T : KoTypeArgumentProvider> List<T>.withTypeArgument(predicate: (KoTypeArgumentDeclaration) -> Boolean): List<T>

List containing declarations that have at least one type argument satisfying the provided predicate.

withTypeArgumentNamed

fun <T : KoTypeArgumentProvider> List<T>.withTypeArgumentNamed(names: Collection<String>): List<T>

fun <T : KoTypeArgumentProvider> List<T>.withTypeArgumentNamed(name: String, vararg names: String): List<T>

List containing declarations that have at least one type argument with the specified name(s).

withTypeArguments

fun <T : KoTypeArgumentProvider> List<T>.withTypeArguments(): List<T>

List containing declarations with any type argument.

fun <T : KoTypeArgumentProvider> List<T>.withTypeArguments(predicate: (List<KoTypeArgumentDeclaration>) -> Boolean): List<T>

List containing declarations with type argument declarations satisfying the predicate.

withTypeOf

fun <T : KoNonNullableTypeProvider> List<T>.withTypeOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoNullableTypeProvider> List<T>.withTypeOf(kClasses: Collection<KClass<*>>): List<T>

fun <T : KoNonNullableTypeProvider> List<T>.withTypeOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

fun <T : KoNullableTypeProvider> List<T>.withTypeOf(kClass: KClass<*>, vararg kClasses: KClass<*>): List<T>

List containing declarations with type of.

withTypeParameter

fun <T : KoTypeParameterProvider> List<T>.withTypeParameter(predicate: (KoTypeParameterDeclaration) -> Boolean): List<T>

List containing declarations that have at least one type parameter satisfying the provided predicate.

withTypeParameterDeclaration

fun <T : KoDeclarationCastProvider> List<T>.withTypeParameterDeclaration(predicate: (KoTypeParameterDeclaration) -> Boolean? = null): List<T>

List containing declarations with the specified type parameter declaration.

withTypeParameterNamed

fun <T : KoTypeParameterProvider> List<T>.withTypeParameterNamed(names: Collection<String>): List<T>

fun <T : KoTypeParameterProvider> List<T>.withTypeParameterNamed(name: String, vararg names: String): List<T>

List containing declarations that have at least one type parameter with the specified name(s).

withTypeParameters

fun <T : KoTypeParameterProvider> List<T>.withTypeParameters(): List<T>

List containing declarations with any type parameter.

fun <T : KoTypeParameterProvider> List<T>.withTypeParameters(predicate: (List<KoTypeParameterDeclaration>) -> Boolean): List<T>

List containing declarations with type parameter declarations satisfying the predicate.

withUpperBound

fun <T : KoUpperBoundsProvider> List<T>.withUpperBound(predicate: (KoTypeDeclaration) -> Boolean): List<T>

List containing declarations that have at least one upper bound satisfying the provided predicate.

withUpperBoundNamed

fun <T : KoUpperBoundsProvider> List<T>.withUpperBoundNamed(names: Collection<String>): List<T>

fun <T : KoUpperBoundsProvider> List<T>.withUpperBoundNamed(name: String, vararg names: String): List<T>

List containing declarations that have at least one upper bound with the specified name(s).

withUpperBounds

fun <T : KoUpperBoundsProvider> List<T>.withUpperBounds(): List<T>

List containing declarations with any upper bound.

fun <T : KoUpperBoundsProvider> List<T>.withUpperBounds(predicate: (List<KoTypeDeclaration>) -> Boolean): List<T>

List containing declarations with upper bound declarations satisfying the predicate.

withVal

fun <T : KoIsValProvider> List<T>.withVal(): List<T>

List containing declarations with val keyword.

withValue

fun <T : KoValueProvider> List<T>.withValue(vararg values: String): List<T>

fun <T : KoValueProvider> List<T>.withValue(values: Collection<String>): List<T>

List containing elements with value.

fun <T : KoValueProvider> List<T>.withValue(predicate: (String) -> Boolean): List<T>

List containing declarations that have a value matching the provided predicate.

withVar

fun <T : KoIsVarProvider> List<T>.withVar(): List<T>

List containing declarations with var keyword.

withVariable

fun <T : KoVariableProvider> List<T>.withVariable(predicate: (KoVariableDeclaration) -> Boolean): List<T>

List containing declarations that have at least one variable satisfying the provided predicate.

withVariableNamed

fun <T : KoVariableProvider> List<T>.withVariableNamed(names: Collection<String>): List<T>

fun <T : KoVariableProvider> List<T>.withVariableNamed(name: String, vararg names: String): List<T>

List containing declarations that have at least one variable with the specified name(s).

withVariables

fun <T : KoVariableProvider> List<T>.withVariables(): List<T>

List containing declarations with any variable.

fun <T : KoVariableProvider> List<T>.withVariables(predicate: (List<KoVariableDeclaration>) -> Boolean): List<T>

List containing declarations with variable declarations satisfying the predicate.

withWildcard

fun <T : KoIsWildcardProvider> List<T>.withWildcard(): List<T>

List containing declarations with a wildcard.